diff --git a/Language/Haskell/Tools/AST.hs b/Language/Haskell/Tools/AST.hs --- a/Language/Haskell/Tools/AST.hs +++ b/Language/Haskell/Tools/AST.hs @@ -10,18 +10,18 @@ import Language.Haskell.Tools.AST.References as Exported import Language.Haskell.Tools.AST.Helpers as Exported -import Language.Haskell.Tools.AST.Modules as Exported -import Language.Haskell.Tools.AST.TH as Exported -import Language.Haskell.Tools.AST.Decls as Exported -import Language.Haskell.Tools.AST.Binds as Exported -import Language.Haskell.Tools.AST.Exprs as Exported -import Language.Haskell.Tools.AST.Stmts as Exported -import Language.Haskell.Tools.AST.Patterns as Exported -import Language.Haskell.Tools.AST.Types as Exported -import Language.Haskell.Tools.AST.Kinds as Exported -import Language.Haskell.Tools.AST.Literals as Exported -import Language.Haskell.Tools.AST.Base as Exported +import Language.Haskell.Tools.AST.Representation.Modules as Exported +import Language.Haskell.Tools.AST.Representation.TH as Exported +import Language.Haskell.Tools.AST.Representation.Decls as Exported +import Language.Haskell.Tools.AST.Representation.Binds as Exported +import Language.Haskell.Tools.AST.Representation.Exprs as Exported +import Language.Haskell.Tools.AST.Representation.Stmts as Exported +import Language.Haskell.Tools.AST.Representation.Patterns as Exported +import Language.Haskell.Tools.AST.Representation.Types as Exported +import Language.Haskell.Tools.AST.Representation.Kinds as Exported +import Language.Haskell.Tools.AST.Representation.Literals as Exported +import Language.Haskell.Tools.AST.Representation.Names as Exported import Language.Haskell.Tools.AST.Ann as Exported import Language.Haskell.Tools.AST.Utils.OrdSrcSpan as Exported -import Language.Haskell.Tools.AST.SemaInfoTypes as Exported -import Language.Haskell.Tools.AST.SemaInfoClasses as Exported +import Language.Haskell.Tools.AST.SemaInfoClasses as Exported +-- import Language.Haskell.Tools.AST.SemaInfoTypes (NoSemanticInfo, ScopeInfo, NameInfo, ) as Exported diff --git a/Language/Haskell/Tools/AST/Ann.hs b/Language/Haskell/Tools/AST/Ann.hs --- a/Language/Haskell/Tools/AST/Ann.hs +++ b/Language/Haskell/Tools/AST/Ann.hs @@ -10,6 +10,7 @@ , AllowAmbiguousTypes , TypeApplications , ScopedTypeVariables + , PatternSynonyms #-} -- | Parts of AST representation for keeping extra data module Language.Haskell.Tools.AST.Ann where @@ -27,9 +28,9 @@ import Language.Haskell.Tools.AST.Utils.GHCInstances import Language.Haskell.Tools.AST.SemaInfoTypes -import {-# SOURCE #-} Language.Haskell.Tools.AST.Modules as AST -import {-# SOURCE #-} Language.Haskell.Tools.AST.Base as AST -import {-# SOURCE #-} Language.Haskell.Tools.AST.Exprs as AST +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Modules as AST +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Names as AST +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs as AST -- * Annotation type resolution @@ -82,11 +83,11 @@ data SameInfoWildcardCls type family SemaInfoClassify (node :: * -> * -> *) where - SemaInfoClassify QualifiedName = SameInfoNameCls - SemaInfoClassify Expr = SameInfoExprCls - SemaInfoClassify ImportDecl = SameInfoImportCls - SemaInfoClassify AST.Module = SameInfoModuleCls - SemaInfoClassify FieldWildcard = SameInfoWildcardCls + SemaInfoClassify UQualifiedName = SameInfoNameCls + SemaInfoClassify UExpr = SameInfoExprCls + SemaInfoClassify UImportDecl = SameInfoImportCls + SemaInfoClassify AST.UModule = SameInfoModuleCls + SemaInfoClassify UFieldWildcard = SameInfoWildcardCls SemaInfoClassify a = SameInfoDefaultCls type family SemanticInfo' (domain :: *) (nodecls :: *) @@ -172,11 +173,11 @@ , HasRange (OptionalInfo stage) ) => SourceInfo stage where - -- | Type of source info for normal AST elements + -- | UType of source info for normal AST elements data SpanInfo stage :: * - -- | Type of source info for lists of AST elements + -- | UType of source info for lists of AST elements data ListInfo stage :: * - -- | Type of source info for optional AST elements + -- | UType of source info for optional AST elements data OptionalInfo stage :: * @@ -256,6 +257,15 @@ -- * Annotations +-- | Semantic and source code related information for an AST node. +data NodeInfo sema src + = NodeInfo { _semanticInfo :: sema + , _sourceInfo :: src + } + deriving (Eq, Show, Data) + +makeReferences ''NodeInfo + -- | An element of the AST keeping extra information. data Ann elem dom stage -- The type parameters are organized this way because we want the annotation type to @@ -269,44 +279,43 @@ -- | A list of AST elements -data AnnList elem dom stage = AnnList { _annListAnnot :: NodeInfo (SemanticInfo dom (AnnList elem)) (ListInfo stage) - , _annListElems :: [Ann elem dom stage] - } - -makeReferences ''AnnList +data AnnListG elem dom stage = AnnListG { _annListAnnot :: NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage) + , _annListElems :: [Ann elem dom stage] + } + +makeReferences ''AnnListG -annList :: Traversal (AnnList e d s) (AnnList e d s) (Ann e d s) (Ann e d s) +annList :: Traversal (AnnListG e d s) (AnnListG e d s) (Ann e d s) (Ann e d s) annList = annListElems & traversal -- | An optional AST element -data AnnMaybe elem dom stage = AnnMaybe { _annMaybeAnnot :: NodeInfo (SemanticInfo dom (AnnMaybe elem)) (OptionalInfo stage) - , _annMaybe :: Maybe (Ann elem dom stage) - } +data AnnMaybeG elem dom stage = AnnMaybeG { _annMaybeAnnot :: NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage) + , _annMaybe :: Maybe (Ann elem dom stage) + } -makeReferences ''AnnMaybe +makeReferences ''AnnMaybeG -annJust :: Partial (AnnMaybe e d s) (AnnMaybe e d s) (Ann e d s) (Ann e d s) +annJust :: Partial (AnnMaybeG e d s) (AnnMaybeG e d s) (Ann e d s) (Ann e d s) annJust = annMaybe & just -- | An empty list of AST elements -annNil :: NodeInfo (SemanticInfo d (AnnList e)) (ListInfo s) -> AnnList e d s -annNil a = AnnList a [] +annNil :: NodeInfo (SemanticInfo d (AnnListG e)) (ListInfo s) -> AnnListG e d s +annNil a = AnnListG a [] -isAnnNothing :: AnnMaybe e d s -> Bool -isAnnNothing (AnnMaybe _ Nothing) = True -isAnnNothing (AnnMaybe _ _) = False +isAnnNothing :: AnnMaybeG e d s -> Bool +isAnnNothing (AnnMaybeG _ Nothing) = True +isAnnNothing (AnnMaybeG _ _) = False -isAnnJust :: AnnMaybe e d s -> Bool -isAnnJust (AnnMaybe _ (Just _)) = True -isAnnJust (AnnMaybe _ _) = False +isAnnJust :: AnnMaybeG e d s -> Bool +isAnnJust (AnnMaybeG _ (Just _)) = True +isAnnJust (AnnMaybeG _ _) = False -annLength :: AnnList e d s -> Int -annLength (AnnList _ ls) = length ls +annLength :: AnnListG e d s -> Int +annLength (AnnListG _ ls) = length ls -- | A non-existing AST part -annNothing :: NodeInfo (SemanticInfo d (AnnMaybe e)) (OptionalInfo s) -> AnnMaybe e d s -annNothing a = AnnMaybe a Nothing - +annNothing :: NodeInfo (SemanticInfo d (AnnMaybeG e)) (OptionalInfo s) -> AnnMaybeG e d s +annNothing a = AnnMaybeG a Nothing -- * Info types @@ -338,12 +347,12 @@ getRange (Ann a _) = getRange (a ^. sourceInfo) setRange sp = annotation & sourceInfo .- setRange sp -instance SourceInfo stage => HasRange (AnnList elem dom stage) where - getRange (AnnList a _) = getRange (a ^. sourceInfo) +instance SourceInfo stage => HasRange (AnnListG elem dom stage) where + getRange (AnnListG a _) = getRange (a ^. sourceInfo) setRange sp = annListAnnot & sourceInfo .- setRange sp -instance SourceInfo stage => HasRange (AnnMaybe elem dom stage) where - getRange (AnnMaybe a _) = getRange (a ^. sourceInfo) +instance SourceInfo stage => HasRange (AnnMaybeG elem dom stage) where + getRange (AnnMaybeG a _) = getRange (a ^. sourceInfo) setRange sp = annMaybeAnnot & sourceInfo .- setRange sp -- | A class for changing semantic information throught the AST. @@ -374,11 +383,11 @@ instance forall e . (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (Ann e) where semaTraverse f (Ann (NodeInfo sema src) e) = Ann <$> (NodeInfo <$> appSemaChange @(SemaInfoClassify e) f sema <*> pure src) <*> semaTraverse f e -instance (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnList e) where - semaTraverse f (AnnList (NodeInfo sema src) e) = AnnList <$> (NodeInfo <$> trfSemaDefault f sema <*> pure src) <*> mapM (semaTraverse f) e +instance (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnListG e) where + semaTraverse f (AnnListG (NodeInfo sema src) e) = AnnListG <$> (NodeInfo <$> trfSemaDefault f sema <*> pure src) <*> mapM (semaTraverse f) e -instance (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnMaybe e) where - semaTraverse f (AnnMaybe (NodeInfo sema src) e) = AnnMaybe <$> (NodeInfo <$> trfSemaDefault f sema <*> pure src) <*> sequence (fmap (semaTraverse f) e) +instance (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnMaybeG e) where + semaTraverse f (AnnMaybeG (NodeInfo sema src) e) = AnnMaybeG <$> (NodeInfo <$> trfSemaDefault f sema <*> pure src) <*> sequence (fmap (semaTraverse f) e) -- | A class for traversing source information in an AST class SourceInfoTraversal a where @@ -400,19 +409,19 @@ sourceInfoTraverseUp trf desc asc (Ann (NodeInfo sema src) e) = flip Ann <$> (desc *> sourceInfoTraverseUp trf desc asc e <* asc) <*> (NodeInfo sema <$> trfSpanInfo trf src) -instance SourceInfoTraversal e => SourceInfoTraversal (AnnList e) where - sourceInfoTraverse trf (AnnList (NodeInfo sema src) e) - = AnnList <$> (NodeInfo sema <$> trfListInfo trf src) <*> mapM (sourceInfoTraverse trf) e - sourceInfoTraverseDown trf desc asc (AnnList (NodeInfo sema src) e) - = AnnList <$> (NodeInfo sema <$> trfListInfo trf src) <*> (desc *> mapM (sourceInfoTraverseDown trf desc asc) e <* asc) - sourceInfoTraverseUp trf desc asc (AnnList (NodeInfo sema src) e) - = flip AnnList <$> (desc *> mapM (sourceInfoTraverseUp trf desc asc) e <* asc) <*> (NodeInfo sema <$> trfListInfo trf src) +instance SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) where + sourceInfoTraverse trf (AnnListG (NodeInfo sema src) e) + = AnnListG <$> (NodeInfo sema <$> trfListInfo trf src) <*> mapM (sourceInfoTraverse trf) e + sourceInfoTraverseDown trf desc asc (AnnListG (NodeInfo sema src) e) + = AnnListG <$> (NodeInfo sema <$> trfListInfo trf src) <*> (desc *> mapM (sourceInfoTraverseDown trf desc asc) e <* asc) + sourceInfoTraverseUp trf desc asc (AnnListG (NodeInfo sema src) e) + = flip AnnListG <$> (desc *> mapM (sourceInfoTraverseUp trf desc asc) e <* asc) <*> (NodeInfo sema <$> trfListInfo trf src) -instance SourceInfoTraversal e => SourceInfoTraversal (AnnMaybe e) where - sourceInfoTraverse trf (AnnMaybe (NodeInfo sema src) e) - = AnnMaybe <$> (NodeInfo sema <$> trfOptionalInfo trf src) <*> sequence (fmap (sourceInfoTraverse trf) e) - sourceInfoTraverseDown trf desc asc (AnnMaybe (NodeInfo sema src) e) - = AnnMaybe <$> (NodeInfo sema <$> trfOptionalInfo trf src) <*> (desc *> sequence (fmap (sourceInfoTraverseDown trf desc asc) e) <* asc) - sourceInfoTraverseUp trf desc asc (AnnMaybe (NodeInfo sema src) e) - = flip AnnMaybe <$> (desc *> sequence (fmap (sourceInfoTraverseUp trf desc asc) e) <* asc) <*> (NodeInfo sema <$> trfOptionalInfo trf src) +instance SourceInfoTraversal e => SourceInfoTraversal (AnnMaybeG e) where + sourceInfoTraverse trf (AnnMaybeG (NodeInfo sema src) e) + = AnnMaybeG <$> (NodeInfo sema <$> trfOptionalInfo trf src) <*> sequence (fmap (sourceInfoTraverse trf) e) + sourceInfoTraverseDown trf desc asc (AnnMaybeG (NodeInfo sema src) e) + = AnnMaybeG <$> (NodeInfo sema <$> trfOptionalInfo trf src) <*> (desc *> sequence (fmap (sourceInfoTraverseDown trf desc asc) e) <* asc) + sourceInfoTraverseUp trf desc asc (AnnMaybeG (NodeInfo sema src) e) + = flip AnnMaybeG <$> (desc *> sequence (fmap (sourceInfoTraverseUp trf desc asc) e) <* asc) <*> (NodeInfo sema <$> trfOptionalInfo trf src) diff --git a/Language/Haskell/Tools/AST/Base.hs b/Language/Haskell/Tools/AST/Base.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Base.hs +++ /dev/null @@ -1,121 +0,0 @@ - -{-# LANGUAGE TypeFamilies - , MultiParamTypeClasses - , FlexibleInstances - #-} - --- | Simple AST elements of Haskell -module Language.Haskell.Tools.AST.Base where - -import Language.Haskell.Tools.AST.Ann - -data Operator dom stage - = BacktickOp { _operatorName :: Ann QualifiedName dom stage } -- ^ Backtick operator name: @ a `mod` b @ - | NormalOp { _operatorName :: Ann QualifiedName dom stage } - -data Name dom stage - = ParenName { _simpleName :: Ann QualifiedName dom stage } -- ^ Parenthesized name: @ foldl (+) 0 @ - | NormalName { _simpleName :: Ann QualifiedName dom stage } - | ImplicitName { _simpleName :: Ann QualifiedName dom stage } -- ^ Implicit name: @ ?var @ - --- | Possible qualified names. Contains also implicit names. --- Linear implicit parameter: @%x@. Non-linear implicit parameter: @?x@. -data QualifiedName dom stage - = QualifiedName { _qualifiers :: AnnList UnqualName dom stage - , _unqualifiedName :: Ann UnqualName dom stage - } - -nameFromList :: AnnList UnqualName dom stage -> QualifiedName dom stage -nameFromList (AnnList a xs) | not (null xs) - = QualifiedName (AnnList a (init xs)) (last xs) -nameFromList _ = error "nameFromList: empty list" - --- | Parts of a qualified name. -data UnqualName dom stage - = UnqualName { _simpleNameStr :: String } - --- | Program elements formatted as string literals (import packages, pragma texts) -data StringNode dom stage - = StringNode { _stringNodeStr :: String } - --- | The name of a module -data ModuleName dom stage = ModuleName { _moduleNameString :: String } - --- | The @data@ or the @newtype@ keyword to define ADTs. -data DataOrNewtypeKeyword dom stage - = DataKeyword - | NewtypeKeyword - --- | Keywords @do@ or @mdo@ to start a do-block -data DoKind dom stage - = DoKeyword - | MDoKeyword - --- | The @type@ keyword used to qualify that the type and not the constructor of the same name is referred -data TypeKeyword dom stage = TypeKeyword - --- | Recognised overlaps for overlap pragmas. Can be applied to class declarations and class instance declarations. -data OverlapPragma dom stage - = EnableOverlap -- ^ @OVERLAP@ pragma - | DisableOverlap -- ^ @NO_OVERLAP@ pragma - | Overlappable -- ^ @OVERLAPPABLE@ pragma - | Overlapping -- ^ @OVERLAPPING@ pragma - | Overlaps -- ^ @OVERLAPS@ pragma - | IncoherentOverlap -- ^ @INCOHERENT@ pragma - --- | Call conventions of foreign functions -data CallConv dom stage - = StdCall - | CCall - | CPlusPlus - | DotNet - | Jvm - | Js - | JavaScript - | CApi - -data ArrowAppl dom stage - = LeftAppl -- ^ Left arrow application: @-<@ - | RightAppl -- ^ Right arrow application: @>-@ - | LeftHighApp -- ^ Left arrow high application: @-<<@ - | RightHighApp -- ^ Right arrow high application: @>>-@ - --- | Safety annotations for foreign calls -data Safety dom stage - = Safe - | ThreadSafe - | Unsafe - | Interruptible - --- | Associativity of an operator. -data Assoc dom stage - = AssocNone -- ^ non-associative operator (declared with @infix@) - | AssocLeft -- ^ left-associative operator (declared with @infixl@) - | AssocRight -- ^ right-associative operator (declared with @infixr@) - -data Role dom stage - = Nominal - | Representational - | Phantom - -data ConlikeAnnot dom stage = ConlikeAnnot - --- | Numeric precedence of an operator -data Precedence dom stage - = Precedence { _precedenceValue :: Int } - -data LineNumber dom stage - = LineNumber { _lineNumber :: Int } - --- | Controls the activation of a rewrite rule (@ [1] @) -data PhaseControl dom stage - = PhaseControl { _phaseUntil :: AnnMaybe PhaseInvert dom stage - , _phaseNumber :: Ann PhaseNumber dom stage - } - --- | Phase number for rewrite rules -data PhaseNumber dom stage - = PhaseNumber { _phaseNum :: Integer } - --- | A tilde that marks the inversion of the phase number -data PhaseInvert dom stage = PhaseInvert diff --git a/Language/Haskell/Tools/AST/Base.hs-boot b/Language/Haskell/Tools/AST/Base.hs-boot deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Base.hs-boot +++ /dev/null @@ -1,5 +0,0 @@ -{-# LANGUAGE RoleAnnotations #-} -module Language.Haskell.Tools.AST.Base where - -type role QualifiedName nominal nominal -data QualifiedName dom stage diff --git a/Language/Haskell/Tools/AST/Binds.hs b/Language/Haskell/Tools/AST/Binds.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Binds.hs +++ /dev/null @@ -1,151 +0,0 @@ --- | Representation of Haskell AST value and function bindings (both local and top-level) -module Language.Haskell.Tools.AST.Binds where - -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Literals -import {-# SOURCE #-} Language.Haskell.Tools.AST.TH - --- | Value binding for top-level and local bindings -data ValueBind dom stage - = SimpleBind { _valBindPat :: Ann Pattern dom stage - , _valBindRhs :: Ann Rhs dom stage - , _valBindLocals :: AnnMaybe LocalBinds dom stage - } -- ^ Non-function binding (@ v = "12" @) - -- TODO: use one name for a function instead of names in each match - | FunBind { _funBindMatches :: AnnList Match dom stage - } -- ^ Function binding (@ f 0 = 1; f x = x @). All matches must have the same name. - --- | Clause of function (or value) binding -data Match dom stage - = Match { _matchLhs :: Ann MatchLhs dom stage - , _matchRhs :: Ann Rhs dom stage - , _matchBinds :: AnnMaybe LocalBinds dom stage - } - --- | Something on the left side of the match -data MatchLhs dom stage - = NormalLhs { _matchLhsName :: Ann Name dom stage - , _matchLhsArgs :: AnnList Pattern dom stage - } - | InfixLhs { _matchLhsLhs :: Ann Pattern dom stage - , _matchLhsOperator :: Ann Operator dom stage - , _matchLhsRhs :: Ann Pattern dom stage - , _matchLhsArgs :: AnnList Pattern dom stage - } - --- | Local bindings attached to a declaration (@ where x = 42 @) -data LocalBinds dom stage - = LocalBinds { _localBinds :: AnnList LocalBind dom stage - } - --- | Bindings that are enabled in local blocks (where or let). -data LocalBind dom stage - = LocalValBind { _localVal :: Ann ValueBind dom stage - } - -- TODO: check that no other signature can be inside a local binding - | LocalSignature { _localSig :: Ann TypeSignature dom stage - } - | LocalFixity { _localFixity :: Ann FixitySignature dom stage - } - --- | A type signature (@ _f :: Int -> Int @) -data TypeSignature dom stage - = TypeSignature { _tsName :: AnnList Name dom stage - , _tsType :: Ann Type dom stage - } - --- | A fixity signature (@ infixl 5 +, - @). -data FixitySignature dom stage - = FixitySignature { _fixityAssoc :: Ann Assoc dom stage - , _fixityPrecedence :: Ann Precedence dom stage - , _fixityOperators :: AnnList Operator dom stage - } - --- | Right hand side of a value binding (possible with guards): (@ = 3 @ or @ | x == 1 = 3; | otherwise = 4 @) -data Rhs dom stage - = UnguardedRhs { _rhsExpr :: Ann Expr dom stage - } - | GuardedRhss { _rhsGuards :: AnnList GuardedRhs dom stage - } - --- | A guarded right-hand side of a value binding (@ | x > 3 = 2 @) -data GuardedRhs dom stage - = GuardedRhs { _guardStmts :: AnnList RhsGuard dom stage -- ^ Cannot be empty. - , _guardExpr :: Ann Expr dom stage - } - --- | Guards for value bindings and pattern matches (@ Just v <- x, v > 1 @) -data RhsGuard dom stage - = GuardBind { _guardPat :: Ann Pattern dom stage - , _guardRhs :: Ann Expr dom stage - } - | GuardLet { _guardBinds :: AnnList LocalBind dom stage - } - | GuardCheck { _guardCheck :: Ann Expr dom stage - } - --- * Pragmas - --- | Top level pragmas -data TopLevelPragma dom stage - = RulePragma { _pragmaRule :: AnnList Rule dom stage - } - | DeprPragma { _pragmaObjects :: AnnList Name dom stage - , _pragmaMessage :: Ann StringNode dom stage - } - | WarningPragma { _pragmaObjects :: AnnList Name dom stage - , _pragmaMessage :: Ann StringNode dom stage - } - | AnnPragma { _annotationSubject :: Ann AnnotationSubject dom stage - , _annotateExpr :: Ann Expr dom stage - } - | InlinePragma { _pragmaConlike :: AnnMaybe ConlikeAnnot dom stage - , _pragmaPhase :: AnnMaybe PhaseControl dom stage - , _inlineDef :: Ann Name dom stage - } - | NoInlinePragma { _pragmaConlike :: AnnMaybe ConlikeAnnot dom stage - , _pragmaPhase :: AnnMaybe PhaseControl dom stage - , _noInlineDef :: Ann Name dom stage - } - | InlinablePragma { _pragmaPhase :: AnnMaybe PhaseControl dom stage - , _inlinableDef :: Ann Name dom stage - } - | LinePragma { _pragmaLineNum :: Ann LineNumber dom stage - , _pragmaFileName :: AnnMaybe StringNode dom stage - } - | SpecializePragma { _pragmaPhase :: AnnMaybe PhaseControl dom stage - , _specializeDef :: Ann Name dom stage - , _specializeType :: AnnList Type dom stage - } - --- | A rewrite rule (@ "map/map" forall f g xs. map f (map g xs) = map (f.g) xs @) -data Rule dom stage - = Rule { _ruleName :: Ann StringNode dom stage -- ^ User name of the rule - , _rulePhase :: AnnMaybe PhaseControl dom stage -- ^ The compilation phases in which the rule can be applied - , _ruleBounded :: AnnList TyVar dom stage -- ^ Variables bound in the rule - , _ruleLhs :: Ann Expr dom stage -- ^ The transformed expression - , _ruleRhs :: Ann Expr dom stage -- ^ The resulting expression - } - --- | Annotation allows you to connect an expression to any declaration. -data AnnotationSubject dom stage - = NameAnnotation { _annotateName :: Ann Name dom stage - } -- ^ The definition with the given name is annotated - | TypeAnnotation { _annotateName :: Ann Name dom stage - } -- ^ A type with the given name is annotated - | ModuleAnnotation -- ^ The whole module is annotated - --- | Formulas of minimal annotations declaring which functions should be defined. -data MinimalFormula dom stage - = MinimalName { _minimalName :: Ann Name dom stage - } - | MinimalParen { _minimalInner :: Ann MinimalFormula dom stage - } - | MinimalOr { _minimalOrs :: AnnList MinimalFormula dom stage - } -- ^ One of the minimal formulas are needed (@ min1 | min2 @) - | MinimalAnd { _minimalAnds :: AnnList MinimalFormula dom stage - } -- ^ Both of the minimal formulas are needed (@ min1 , min2 @) diff --git a/Language/Haskell/Tools/AST/Binds.hs-boot b/Language/Haskell/Tools/AST/Binds.hs-boot deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Binds.hs-boot +++ /dev/null @@ -1,11 +0,0 @@ -{-# LANGUAGE RoleAnnotations #-} -module Language.Haskell.Tools.AST.Binds where - -type role LocalBind nominal nominal -data LocalBind dom stage - -type role LocalBinds nominal nominal -data LocalBinds dom stage - -type role RhsGuard nominal nominal -data RhsGuard dom stage diff --git a/Language/Haskell/Tools/AST/Decls.hs b/Language/Haskell/Tools/AST/Decls.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Decls.hs +++ /dev/null @@ -1,299 +0,0 @@ --- | Representation of Haskell AST definitions. These include definition of data types, classes, instances and so on. --- The definition of value bindings are in the Binds module. -module Language.Haskell.Tools.AST.Decls where - -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Ann -import {-# SOURCE #-} Language.Haskell.Tools.AST.TH - - --- | Haskell declaration -data Decl dom stage - = TypeDecl { _declHead :: Ann DeclHead dom stage - , _declType :: Ann Type dom stage - } -- ^ A type synonym ( @type String = [Char]@ ) - | TypeFamilyDecl { _declTypeFamily :: Ann TypeFamily dom stage - } - | ClosedTypeFamilyDecl { _declHead :: Ann DeclHead dom stage - , _declKind :: AnnMaybe KindConstraint dom stage - , _declDecl :: AnnList TypeEqn dom stage -- ^ cannot be empty - } -- ^ A closed type family declaration - | DataDecl { _declNewtype :: Ann DataOrNewtypeKeyword dom stage - , _declCtx :: AnnMaybe Context dom stage - , _declHead :: Ann DeclHead dom stage - , _declCons :: AnnList ConDecl dom stage - , _declDeriving :: AnnMaybe Deriving dom stage - } -- ^ A data or newtype declaration. Empty data type declarations without - -- where keyword are always belong to DataDecl. - | GDataDecl { _declNewtype :: Ann DataOrNewtypeKeyword dom stage - , _declCtx :: AnnMaybe Context dom stage - , _declHead :: Ann DeclHead dom stage - , _declKind :: AnnMaybe KindConstraint dom stage - , _declGadt :: AnnList GadtConDecl dom stage - , _declDeriving :: AnnMaybe Deriving dom stage - } -- ^ A data or newtype declaration. - | TypeInstDecl { _declInstance :: Ann InstanceRule dom stage - , _declAssignedType :: Ann Type dom stage - } -- ^ Type instance declaration (@ type instance Fam T = AssignedT @) - | DataInstDecl { _declNewtype :: Ann DataOrNewtypeKeyword dom stage - , _declInstance :: Ann InstanceRule dom stage - , _declCons :: AnnList ConDecl dom stage - , _declDeriving :: AnnMaybe Deriving dom stage - } -- ^ Data instance declaration (@ data instance Fam T = Con1 | Con2 @) - | GDataInstDecl { _declNewtype :: Ann DataOrNewtypeKeyword dom stage - , _declInstance :: Ann InstanceRule dom stage - , _declKind :: AnnMaybe KindConstraint dom stage - , _declGadt :: AnnList GadtConDecl dom stage - } -- ^ Gadt style data instance declaration (@ data instance Fam T where ... @) - | ClassDecl { _declCtx :: AnnMaybe Context dom stage - , _declHead :: Ann DeclHead dom stage - , _declFunDeps :: AnnMaybe FunDeps dom stage - , _declBody :: AnnMaybe ClassBody dom stage - } -- ^ Type class declaration (@ class X a [where f = ...] @) - | InstDecl { _declOverlap :: AnnMaybe OverlapPragma dom stage - , _declInstRule :: Ann InstanceRule dom stage - , _declInstDecl :: AnnMaybe InstBody dom stage - } -- ^ Instance declaration (@ instance X T [where f = ...] @) - | PatternSynonymDecl { _declPatSyn :: Ann PatternSynonym dom stage - } -- ^ Pattern synonyms (@ pattern Arrow t1 t2 = App "->" [t1, t2] @) - | DerivDecl { _declOverlap :: AnnMaybe OverlapPragma dom stage - , _declInstRule :: Ann InstanceRule dom stage - } -- ^ Standalone deriving declaration (@ deriving instance X T @) - | FixityDecl { _declFixity :: Ann FixitySignature dom stage - } -- ^ Fixity declaration (@ infixl 5 +, - @) - | DefaultDecl { _declTypes :: AnnList Type dom stage - } -- ^ Default types (@ default (T1, T2) @) - | TypeSigDecl { _declTypeSig :: Ann TypeSignature dom stage - } -- ^ Type signature declaration (@ _f :: Int -> Int @) - | PatTypeSigDecl { _declPatTypeSig :: Ann PatternTypeSignature dom stage - } -- ^ Type signature declaration (@ _f :: Int -> Int @) - | ValueBinding { _declValBind :: Ann ValueBind dom stage - } -- ^ Function binding (@ f x = 12 @) - | ForeignImport { _declCallConv :: Ann CallConv dom stage - , _declSafety :: AnnMaybe Safety dom stage - , _declName :: Ann Name dom stage - , _declType :: Ann Type dom stage - } -- ^ Foreign import (@ foreign import _foo :: Int -> IO Int @) - | ForeignExport { _declCallConv :: Ann CallConv dom stage - , _declName :: Ann Name dom stage - , _declType :: Ann Type dom stage - } -- ^ foreign export (@ foreign export ccall _foo :: Int -> IO Int @) - | PragmaDecl { _declPragma :: Ann TopLevelPragma dom stage - } -- ^ top level pragmas - | RoleDecl { _declRoleType :: Ann QualifiedName dom stage - , _declRoles :: AnnList Role dom stage - } -- ^ role annotations (@ type role Ptr representational @) - | SpliceDecl { _declSplice :: Ann Splice dom stage - } -- ^ A Template Haskell splice declaration (@ $(generateDecls) @) - --- | Open type and data families -data TypeFamily dom stage - = TypeFamily { _tfHead :: Ann DeclHead dom stage - , _tfSpec :: AnnMaybe TypeFamilySpec dom stage - } -- ^ A type family declaration (@ type family A _a :: * -> * @) - | DataFamily { _tfHead :: Ann DeclHead dom stage - , _tfKind :: AnnMaybe KindConstraint dom stage - } -- ^ Data family declaration - --- | Type family specification with kinds specification and injectivity. -data TypeFamilySpec dom stage - = TypeFamilyKind { _tfSpecKind :: Ann KindConstraint dom stage - } - | TypeFamilyInjectivity { _tfInjectivity :: Ann InjectivityAnn dom stage - } - --- | Injectivity annotation for type families (@ = r | r -> a @) -data InjectivityAnn dom stage - = InjectivityAnn { _injAnnRes :: Ann Name dom stage - , _injAnnDeps :: AnnList Name dom stage - } - --- | The list of declarations that can appear in a typeclass -data ClassBody dom stage - = ClassBody { _cbElements :: AnnList ClassElement dom stage - } - --- | Members of a class declaration -data ClassElement dom stage - = ClsSig { _ceTypeSig :: Ann TypeSignature dom stage - } -- ^ Signature: @ _f :: A -> B @ - | ClsDef { _ceBind :: Ann ValueBind dom stage - } -- ^ Default binding: @ f x = "aaa" @ - | ClsTypeFam { _ceTypeFam :: Ann TypeFamily dom stage - } -- ^ Declaration of an associated type synonym: @ type T _x :: * @ - | ClsTypeDef { _ceHead :: Ann DeclHead dom stage - , _ceKind :: Ann Type dom stage - } -- ^ Default choice for type synonym: @ type T x = TE @ or @ type instance T x = TE @ - | ClsDefSig { _ceName :: Ann Name dom stage - , _ceType :: Ann Type dom stage - } -- ^ Default signature (by using @DefaultSignatures@): @ default _enum :: (Generic a, GEnum (Rep a)) => [a] @ - | ClsMinimal { _pragmaFormula :: Ann MinimalFormula dom stage - } -- ^ Minimal pragma: @ {-# MINIMAL (==) | (/=) #-} @ - - -- not supported yet (GHC 7.10.3) - | ClsPatSig { _cePatSig :: Ann PatternTypeSignature dom stage - } -- ^ Pattern signature in a class declaration (by using @PatternSynonyms@) - --- The declared (possibly parameterized) type (@ A x :+: B y @). -data DeclHead dom stage - = DeclHead { _dhName :: Ann Name dom stage - } -- ^ Type or class name - | DHParen { _dhBody :: Ann DeclHead dom stage - } -- ^ Parenthesized type - | DHApp { _dhAppFun :: Ann DeclHead dom stage - , _dhAppOperand :: Ann TyVar dom stage - } -- ^ Type application - | DHInfix { _dhLeft :: Ann TyVar dom stage - , _dhOperator :: Ann Operator dom stage - , _dhRight :: Ann TyVar dom stage - } -- ^ Infix application of the type/class name to the left operand - --- | Instance body is the implementation of the class functions (@ where a x = 1; b x = 2 @) -data InstBody dom stage - = InstBody { _instBodyDecls :: AnnList InstBodyDecl dom stage - } - --- | Declarations inside an instance declaration. -data InstBodyDecl dom stage - = InstBodyNormalDecl { _instBodyDeclFunbind :: Ann ValueBind dom stage - } -- ^ A normal declaration (@ f x = 12 @) - | InstBodyTypeSig { _instBodyTypeSig :: Ann TypeSignature dom stage - } -- ^ Type signature in instance definition with @InstanceSigs@ - | InstBodyTypeDecl { _instBodyTypeEqn :: Ann TypeEqn dom stage - } -- ^ An associated type definition (@ type A X = B @) - | InstBodyDataDecl { _instBodyDataNew :: Ann DataOrNewtypeKeyword dom stage - , _instBodyLhsType :: Ann InstanceRule dom stage - , _instBodyDataCons :: AnnList ConDecl dom stage - , _instBodyDerivings :: AnnMaybe Deriving dom stage - } -- ^ An associated data type implementation (@ data A X = C1 | C2 @) - | InstBodyGadtDataDecl { _instBodyDataNew :: Ann DataOrNewtypeKeyword dom stage - , _instBodyLhsType :: Ann InstanceRule dom stage - , _instBodyDataKind :: AnnMaybe KindConstraint dom stage - , _instBodyGadtCons :: AnnList GadtConDecl dom stage - , _instBodyDerivings :: AnnMaybe Deriving dom stage - } -- ^ An associated data type implemented using GADT style - | SpecializeInstance { _specializeInstanceType :: Ann Type dom stage - } -- ^ Specialize instance pragma (no phase selection is allowed) - -- not supported yet - | InstBodyPatSyn { _instBodyPatSyn :: Ann PatternSynonym dom stage - } -- ^ A pattern synonym in a class instance - --- | GADT constructor declaration (@ _D1 :: { _val :: Int } -> T String @) -data GadtConDecl dom stage - = GadtConDecl { _gadtConNames :: AnnList Name dom stage - , _gadtConType :: Ann GadtConType dom stage - } - --- | Type of GADT constructors (can be record types: @{ _val :: Int }@) -data GadtConType dom stage - = GadtNormalType { _gadtConNormalType :: Ann Type dom stage - } - | GadtRecordType { _gadtConRecordFields :: AnnList FieldDecl dom stage - , _gadtConResultType :: Ann Type dom stage - } - --- | A list of functional dependencies: @ | a -> b, c -> d @ separated by commas -data FunDeps dom stage - = FunDeps { _funDeps :: AnnList FunDep dom stage - } - --- | A functional dependency, given on the form @l1 ... ln -> r1 ... rn@ -data FunDep dom stage - = FunDep { _funDepLhs :: AnnList Name dom stage - , _funDepRhs :: AnnList Name dom stage - } - --- | A constructor declaration for a datatype -data ConDecl dom stage - = ConDecl { _conDeclName :: Ann Name dom stage - , _conDeclArgs :: AnnList Type dom stage - } -- ^ ordinary data constructor (@ C t1 t2 @) - | RecordDecl { _conDeclName :: Ann Name dom stage - , _conDeclFields :: AnnList FieldDecl dom stage - } -- ^ record data constructor (@ C { _n1 :: t1, _n2 :: t2 } @) - | InfixConDecl { _conDeclLhs :: Ann Type dom stage - , _conDeclOp :: Ann Operator dom stage - , _conDeclRhs :: Ann Type dom stage - } -- ^ infix data constructor (@ t1 :+: t2 @) - --- | Field declaration (@ _fld :: Int @) -data FieldDecl dom stage - = FieldDecl { _fieldNames :: AnnList Name dom stage - , _fieldType :: Ann Type dom stage - } - --- | A deriving clause following a data type declaration. (@ deriving Show @ or @ deriving (Show, Eq) @) -data Deriving dom stage - = DerivingOne { _oneDerived :: Ann InstanceHead dom stage } - | Derivings { _allDerived :: AnnList InstanceHead dom stage } - --- | The instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword. -data InstanceRule dom stage - = InstanceRule { _irVars :: AnnMaybe (AnnList TyVar) dom stage - , _irCtx :: AnnMaybe Context dom stage - , _irHead :: Ann InstanceHead dom stage - } - | InstanceParen { _irRule :: Ann InstanceRule dom stage - } - --- | The specification of the class instance declaration -data InstanceHead dom stage - = InstanceHeadCon { _ihConName :: Ann Name dom stage - } -- ^ Type or class name - | InstanceHeadInfix { _ihLeftOp :: Ann Type dom stage - , _ihOperator :: Ann Name dom stage - } -- ^ Infix application of the type/class name to the left operand - | InstanceHeadParen { _ihHead :: Ann InstanceHead dom stage - } -- ^ Parenthesized instance head - | InstanceHeadApp { _ihFun :: Ann InstanceHead dom stage - , _ihType :: Ann Type dom stage - } -- ^ Application to one more type - --- | Type equations as found in closed type families (@ T A = S @) -data TypeEqn dom stage - = TypeEqn { _teLhs :: Ann Type dom stage - , _teRhs :: Ann Type dom stage - } - --- | A pattern type signature (@ pattern p :: Int -> T @) -data PatternTypeSignature dom stage - = PatternTypeSignature { _patSigName :: Ann Name dom stage - , _patSigType :: Ann Type dom stage - } - --- | Pattern synonyms: @ pattern Arrow t1 t2 = App "->" [t1, t2] @ -data PatternSynonym dom stage - = PatternSynonym { _patLhs :: Ann PatSynLhs dom stage - , _patRhs :: Ann PatSynRhs dom stage - } - --- | Left hand side of a pattern synonym -data PatSynLhs dom stage - = NormalPatSyn { _patName :: Ann Name dom stage - , _patArgs :: AnnList Name dom stage - } - | InfixPatSyn { _patSynLhs :: Ann Name dom stage - , _patSynOp :: Ann Operator dom stage - , _patSynRhs :: Ann Name dom stage - } - | RecordPatSyn { _patName :: Ann Name dom stage - , _patArgs :: AnnList Name dom stage - } - --- | Right-hand side of pattern synonym -data PatSynRhs dom stage - = BidirectionalPatSyn { _patRhsPat :: Ann Pattern dom stage - , _patRhsOpposite :: AnnMaybe PatSynWhere dom stage - } -- ^ @ pattern Int = App "Int" [] @ or @ pattern Int <- App "Int" [] where Int = App "Int" [] @ - | OneDirectionalPatSyn { _patRhsPat :: Ann Pattern dom stage - } -- ^ @ pattern Int <- App "Int" [] @ - --- | Where clause of pattern synonym (explicit expression direction) -data PatSynWhere dom stage - = PatSynWhere { _patOpposite :: AnnList Match dom stage } diff --git a/Language/Haskell/Tools/AST/Exprs.hs b/Language/Haskell/Tools/AST/Exprs.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Exprs.hs +++ /dev/null @@ -1,220 +0,0 @@ --- | Representation of Haskell expressions -module Language.Haskell.Tools.AST.Exprs where - -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Stmts -import {-# SOURCE #-} Language.Haskell.Tools.AST.TH -import {-# SOURCE #-} Language.Haskell.Tools.AST.Binds (LocalBind, LocalBinds, RhsGuard) - --- | Haskell expressions -data Expr dom stage - = Var { _exprName :: Ann Name dom stage - } -- ^ A variable or a data constructor (@ a @) - | Lit { _exprLit :: Ann Literal dom stage - } -- ^ Primitive literal - | InfixApp { _exprLhs :: Ann Expr dom stage - , _exprOperator :: Ann Operator dom stage - , _exprRhs :: Ann Expr dom stage - } -- ^ Infix operator application (@ a + b @) - | PrefixApp { _exprOperator :: Ann Operator dom stage - , _exprRhs :: Ann Expr dom stage - } -- ^ Prefix operator application (@ -x @) - | App { _exprFun :: Ann Expr dom stage - , _exprArg :: Ann Expr dom stage - } -- ^ Function application (@ f 4 @) - -- unary minus omitted - | Lambda { _exprBindings :: AnnList Pattern dom stage -- ^ at least one - , _exprInner :: Ann Expr dom stage - } -- ^ Lambda expression (@ \a b -> a + b @) - | Let { _exprFunBind :: AnnList LocalBind dom stage -- ^ nonempty - , _exprInner :: Ann Expr dom stage - } -- ^ Local binding (@ let x = 2; y = 3 in e x y @) - | If { _exprCond :: Ann Expr dom stage - , _exprThen :: Ann Expr dom stage - , _exprElse :: Ann Expr dom stage - } -- ^ If expression (@ if a then b else c @) - | MultiIf { _exprIfAlts :: AnnList GuardedCaseRhs dom stage - } -- ^ Multi way if expressions with @MultiWayIf@ extension (@ if | guard1 -> expr1; guard2 -> expr2 @) - | Case { _exprCase :: Ann Expr dom stage - , _exprAlts :: AnnList Alt dom stage - } -- ^ Pattern matching expression (@ case expr of pat1 -> expr1; pat2 -> expr2 @) - | Do { _doKind :: Ann DoKind dom stage - , _exprStmts :: AnnList Stmt dom stage - } -- ^ Do-notation expressions (@ do x <- act1; act2 @) - | Tuple { _tupleElems :: AnnList Expr dom stage - } -- ^ Tuple expression (@ (e1, e2, e3) @) - | UnboxedTuple { _tupleElems :: AnnList Expr dom stage - } -- ^ Unboxed tuple expression (@ (# e1, e2, e3 #) @) - | TupleSection { _tupleSectionElems :: AnnList TupSecElem dom stage - } -- ^ Tuple section, enabled with @TupleSections@ (@ (a,,b) @). One of the elements must be missing. - | UnboxedTupSec { _tupleSectionElems :: AnnList TupSecElem dom stage - } - | List { _listElems :: AnnList Expr dom stage - } -- ^ List expression: @[1,2,3]@ - | ParArray { _listElems :: AnnList Expr dom stage - } -- ^ Parallel array expression: @[: 1,2,3 :]@ - | Paren { _exprInner :: Ann Expr dom stage - } - | LeftSection { _exprLhs :: Ann Expr dom stage - , _exprOperator :: Ann Operator dom stage - } -- ^ Left operator section: @(1+)@ - | RightSection { _exprOperator :: Ann Operator dom stage - , _exprRhs :: Ann Expr dom stage - } -- ^ Right operator section: @(+1)@ - | RecCon { _exprRecName :: Ann Name dom stage - , _exprRecFields :: AnnList FieldUpdate dom stage - } -- ^ Record value construction: @Point { x = 3, y = -2 }@ - | RecUpdate { _exprInner :: Ann Expr dom stage - , _exprRecFields :: AnnList FieldUpdate dom stage - } -- ^ Record value update: @p1 { x = 3, y = -2 }@ - | Enum { _enumFrom :: Ann Expr dom stage - , _enumThen :: AnnMaybe Expr dom stage - , _enumTo :: AnnMaybe Expr dom stage - } -- ^ Enumeration expression (@ [1,3..10] @) - | ParArrayEnum { _enumFrom :: Ann Expr dom stage - , _enumThen :: AnnMaybe Expr dom stage - , _enumToFix :: Ann Expr dom stage - } -- ^ Parallel array enumeration (@ [: 1,3 .. 10 :] @) - | ListComp { _compExpr :: Ann Expr dom stage - , _compBody :: AnnList ListCompBody dom stage -- ^ Can only have 1 element without @ParallelListComp@ - } -- ^ List comprehension (@ [ (x, y) | x <- xs | y <- ys ] @) - | ParArrayComp { _compExpr :: Ann Expr dom stage - , _compBody :: AnnList ListCompBody dom stage - } -- ^ Parallel array comprehensions @ [: (x, y) | x <- xs , y <- ys :] @ enabled by @ParallelArrays@ - | TypeSig { _exprInner :: Ann Expr dom stage - , _exprSig :: Ann Type dom stage - } -- ^ Explicit type signature (@ _x :: Int @) - | ExplTypeApp { _exprInner :: Ann Expr dom stage - , _exprType :: Ann Type dom stage - } -- ^ Explicit type application (@ show \@Integer (read "5") @) - | VarQuote { _quotedName :: Ann Name dom stage - } -- ^ @'x@ for template haskell reifying of expressions - | TypeQuote { _quotedName :: Ann Name dom stage - } -- ^ @''T@ for template haskell reifying of types - | BracketExpr { _bracket :: Ann Bracket dom stage - } -- ^ Template haskell bracket expression - | Splice { _innerExpr :: Ann Splice dom stage - } -- ^ Template haskell splice expression, for example: @$(gen a)@ or @$x@ - | QuasiQuoteExpr { _exprQQ :: Ann QuasiQuote dom stage - } -- ^ Template haskell quasi-quotation: @[$quoter|str]@ - | ExprPragma { _exprPragma :: Ann ExprPragma dom stage - } - -- Arrows - | Proc { _procPattern :: Ann Pattern dom stage - , _procExpr :: Ann Cmd dom stage - } -- ^ Arrow definition: @proc a -> f -< a+1@ - | ArrowApp { _exprLhs :: Ann Expr dom stage - , _arrowAppl :: Ann ArrowAppl dom stage - , _exprRhs :: Ann Expr dom stage - } -- ^ Arrow application: @f -< a+1@ - | LamCase { _exprAlts :: AnnList Alt dom stage - } -- ^ Lambda case ( @\case 0 -> 1; 1 -> 2@ ) - | StaticPtr { _exprInner :: Ann Expr dom stage - } -- ^ Static pointer expression (@ static e @). The inner expression must be closed (cannot have variables bound outside) - -- XML expressions omitted - --- | Field update expressions -data FieldUpdate dom stage - = NormalFieldUpdate { _fieldName :: Ann Name dom stage - , _fieldValue :: Ann Expr dom stage - } -- ^ Update of a field (@ x = 1 @) - | FieldPun { _fieldUpdateName :: Ann Name dom stage - } -- ^ Update the field to the value of the same name (@ x @) - | FieldWildcard { _fieldWildcard :: Ann FieldWildcard dom stage - } -- ^ Update the fields of the bounded names to their values (@ .. @). Must be the last initializer. Cannot be used in a record update expression. - --- | Marker for a field wildcard. Only needed to attach semantic information in a type-safe way. -data FieldWildcard dom stage = FldWildcard - --- | An element of a tuple section that can be an expression or missing (indicating a value from a parameter) -data TupSecElem dom stage - = Present { _tupSecExpr :: Ann Expr dom stage - } -- ^ An existing element in a tuple section - | Missing -- ^ A missing element in a tuple section - --- | Clause of case expression -data Alt' expr dom stage - = Alt { _altPattern :: Ann Pattern dom stage - , _altRhs :: Ann (CaseRhs' expr) dom stage - , _altBinds :: AnnMaybe LocalBinds dom stage - } -type Alt = Alt' Expr -type CmdAlt = Alt' Cmd - - --- | Right hand side of a match (possible with guards): (@ = 3 @ or @ | x == 1 = 3; | otherwise = 4 @) -data CaseRhs' expr dom stage - = UnguardedCaseRhs { _rhsCaseExpr :: Ann expr dom stage - } - | GuardedCaseRhss { _rhsCaseGuards :: AnnList (GuardedCaseRhs' expr) dom stage - } -type CaseRhs = CaseRhs' Expr -type CmdCaseRhs = CaseRhs' Cmd - --- | A guarded right-hand side of pattern matches binding (@ | x > 3 -> 2 @) -data GuardedCaseRhs' expr dom stage - = GuardedCaseRhs { _caseGuardStmts :: AnnList RhsGuard dom stage -- ^ Cannot be empty. - , _caseGuardExpr :: Ann expr dom stage - } -type GuardedCaseRhs = GuardedCaseRhs' Expr -type CmdGuardedCaseRhs = GuardedCaseRhs' Cmd - --- | Pragmas that can be applied to expressions -data ExprPragma dom stage - = CorePragma { _pragmaStr :: Ann StringNode dom stage - } - | SccPragma { _pragmaStr :: Ann StringNode dom stage - } - | GeneratedPragma { _pragmaSrcRange :: Ann SourceRange dom stage - } - --- | In-AST source ranges (for generated pragmas) -data SourceRange dom stage - = SourceRange { _srFileName :: Ann StringNode dom stage - , _srFromLine :: Ann Number dom stage - , _srFromCol :: Ann Number dom stage - , _srToLine :: Ann Number dom stage - , _srToCol :: Ann Number dom stage - } - -data Number dom stage - = Number { _numberInteger :: Integer - } - -data Cmd dom stage - = ArrowAppCmd { _cmdLhs :: Ann Expr dom stage - , _cmdArrowOp :: Ann ArrowAppl dom stage - , _cmdRhs :: Ann Expr dom stage - } - | ArrowFormCmd { _cmdExpr :: Ann Expr dom stage - , _cmdInnerCmds :: AnnList Cmd dom stage - } - | AppCmd { _cmdInnerCmd :: Ann Cmd dom stage - , _cmdApplied :: Ann Expr dom stage - } - | InfixCmd { _cmdLeftCmd :: Ann Cmd dom stage - , _cmdOperator :: Ann Name dom stage - , _cmdRightCmd :: Ann Cmd dom stage - } - | LambdaCmd { _cmdBindings :: AnnList Pattern dom stage -- ^ at least one - , _cmdInner :: Ann Cmd dom stage - } - | ParenCmd { _cmdInner :: Ann Cmd dom stage - } - | CaseCmd { _cmdExpr :: Ann Expr dom stage - , _cmdAlts :: AnnList CmdAlt dom stage - } - | IfCmd { _cmdExpr :: Ann Expr dom stage - , _cmdThen :: Ann Cmd dom stage - , _cmdElse :: Ann Cmd dom stage - } - | LetCmd { _cmdBinds :: AnnList LocalBind dom stage -- ^ nonempty - , _cmdInner :: Ann Cmd dom stage - } - | DoCmd { _cmdStmts :: AnnList (Stmt' Cmd) dom stage - } - diff --git a/Language/Haskell/Tools/AST/Exprs.hs-boot b/Language/Haskell/Tools/AST/Exprs.hs-boot deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Exprs.hs-boot +++ /dev/null @@ -1,11 +0,0 @@ -{-# LANGUAGE RoleAnnotations #-} -module Language.Haskell.Tools.AST.Exprs where - -type role Expr nominal nominal -data Expr dom stage - -type role Cmd nominal nominal -data Cmd dom stage - -type role FieldWildcard phantom phantom -data FieldWildcard dom stage diff --git a/Language/Haskell/Tools/AST/Helpers.hs b/Language/Haskell/Tools/AST/Helpers.hs --- a/Language/Haskell/Tools/AST/Helpers.hs +++ b/Language/Haskell/Tools/AST/Helpers.hs @@ -3,6 +3,9 @@ , RankNTypes , ScopedTypeVariables , TypeFamilies + , FlexibleInstances + , UndecidableInstances + , PatternSynonyms #-} -- | Helper functions for using the AST. @@ -11,7 +14,7 @@ import SrcLoc import qualified Name as GHC -import Control.Reference hiding (element) +import Control.Reference import Control.Monad import Data.List import Data.Maybe @@ -19,70 +22,39 @@ import Data.Generics.Uniplate.Operations import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.References import Language.Haskell.Tools.AST.SemaInfoTypes +import Language.Haskell.Tools.AST.SemaInfoClasses import Debug.Trace - -ordByOccurrence :: QualifiedName dom stage -> QualifiedName dom stage -> Ordering -ordByOccurrence = compare `on` nameElements - --- | The occurrence of the name. -nameString :: QualifiedName dom stage -> String -nameString = intercalate "." . nameElements - --- | The qualifiers and the unqualified name -nameElements :: QualifiedName dom stage -> [String] -nameElements n = (n ^? qualifiers&annList&element&simpleNameStr) - ++ [n ^. unqualifiedName&element&simpleNameStr] - --- | The qualifier of the name -nameQualifier :: QualifiedName dom stage -> [String] -nameQualifier n = n ^? qualifiers&annList&element&simpleNameStr - + -- | Does the import declaration import only the explicitly listed elements? -importIsExact :: ImportDecl dom stage -> Bool -importIsExact = isJust . (^? importSpec&annJust&element&importSpecList) - --- | Does the import declaration has a 'hiding' clause? -importIsHiding :: ImportDecl dom stage -> Bool -importIsHiding = isJust . (^? importSpec&annJust&element&importSpecHiding) - --- | All elements that are explicitly listed to be imported in the import declaration -importExacts :: Simple Traversal (ImportDecl dom stage) (IESpec dom stage) -importExacts = importSpec&annJust&element&importSpecList&annList&element +importIsExact :: Ann UImportDecl dom stage -> Bool +importIsExact = isJust . (^? importSpec&annJust&importSpecList) --- | All elements that are hidden in an import -importHidings :: Simple Traversal (ImportDecl dom stage) (IESpec dom stage) -importHidings = importSpec&annJust&element&importSpecList&annList&element - --- | Possible qualifiers to use imported definitions -importQualifiers :: ImportDecl dom stage -> [[String]] -importQualifiers imp - = (if isAnnNothing (imp ^. importQualified) then [[]] else []) - ++ [imp ^? importAs&annJust&element&importRename&element&moduleNameString] - -bindingName :: (SemanticInfo dom QualifiedName ~ ni) => Simple Traversal (Ann ValueBind dom stage) ni -bindingName = element&(valBindPat&element&patternName&element&simpleName - &+& funBindMatches&annList&element&matchLhs&element - &(matchLhsName&element&simpleName &+& matchLhsOperator&element&operatorName)) - &semantics - -declHeadNames :: Simple Traversal (Ann DeclHead dom stage) (Ann QualifiedName dom stage) -declHeadNames = element & (dhName&element&simpleName &+& dhBody&declHeadNames &+& dhAppFun&declHeadNames &+& dhOperator&element&operatorName) +-- | Accesses the name of a function or value binding +bindingName :: (SemanticInfo dom UQualifiedName ~ ni) => Simple Traversal (Ann UValueBind dom stage) (Ann UQualifiedName dom stage) +bindingName = (valBindPat&patternName&simpleName + &+& funBindMatches&annList&matchLhs + &(matchLhsName&simpleName &+& matchLhsOperator&operatorName)) - -typeParams :: Simple Traversal (Ann Type dom stage) (Ann Type dom stage) +-- | Accesses that name of a declaration through the declaration head. +declHeadNames :: Simple Traversal (Ann UDeclHead dom stage) (Ann UQualifiedName dom stage) +declHeadNames = (dhName&simpleName &+& dhBody&declHeadNames &+& dhAppFun&declHeadNames &+& dhOperator&operatorName) + +-- | A reference to access type arguments to a type constructor call that may be universally qualified +-- or parenthesized. +typeParams :: Simple Traversal (Ann UType dom stage) (Ann UType dom stage) typeParams = fromTraversal typeParamsTrav - where typeParamsTrav f (Ann a (TyFun p r)) = Ann a <$> (TyFun <$> f p <*> typeParamsTrav f r) - typeParamsTrav f (Ann a (TyForall vs t)) = Ann a <$> (TyForall vs <$> typeParamsTrav f t) - typeParamsTrav f (Ann a (TyCtx ctx t)) = Ann a <$> (TyCtx ctx <$> typeParamsTrav f t) - typeParamsTrav f (Ann a (TyParen t)) = Ann a <$> (TyParen <$> typeParamsTrav f t) + where typeParamsTrav f (Ann a (UTyFun p r)) = Ann a <$> (UTyFun <$> f p <*> typeParamsTrav f r) + typeParamsTrav f (Ann a (UTyForall vs t)) = Ann a <$> (UTyForall vs <$> typeParamsTrav f t) + typeParamsTrav f (Ann a (UTyCtx ctx t)) = Ann a <$> (UTyCtx ctx <$> typeParamsTrav f t) + typeParamsTrav f (Ann a (UTyParen t)) = Ann a <$> (UTyParen <$> typeParamsTrav f t) typeParamsTrav f t = f t @@ -90,50 +62,6 @@ semantics :: Simple Lens (Ann elem dom stage) (SemanticInfo dom elem) semantics = annotation&semanticInfo -dhNames :: (SemanticInfo dom QualifiedName ~ k) => Simple Traversal (Ann DeclHead dom stage) k -dhNames = declHeadNames & semantics - --- | A type class for transformations that work on both top-level and local definitions -class BindingElem d where - sigBind :: Simple Partial (d dom stage) (Ann TypeSignature dom stage) - valBind :: Simple Partial (d dom stage) (Ann ValueBind dom stage) - createTypeSig :: Ann TypeSignature dom stage -> d dom stage - createBinding :: Ann ValueBind dom stage -> d dom stage - isTypeSig :: d dom stage -> Bool - isBinding :: d dom stage -> Bool - -instance BindingElem Decl where - sigBind = declTypeSig - valBind = declValBind - createTypeSig = TypeSigDecl - createBinding = ValueBinding - isTypeSig (TypeSigDecl _) = True - isTypeSig _ = False - isBinding (ValueBinding _) = True - isBinding _ = False - -instance BindingElem LocalBind where - sigBind = localSig - valBind = localVal - createTypeSig = LocalSignature - createBinding = LocalValBind - isTypeSig (LocalSignature _) = True - isTypeSig _ = False - isBinding (LocalValBind _) = True - isBinding _ = False - -bindName :: (BindingElem d, SemanticInfo dom QualifiedName ~ k) => Simple Traversal (d dom stage) k -bindName = valBind&bindingName &+& sigBind&element&tsName&annList&element&simpleName&semantics - -valBindsInList :: BindingElem d => Simple Traversal (AnnList d dom stage) (Ann ValueBind dom stage) -valBindsInList = annList & element & valBind - -getValBindInList :: (BindingElem d, SourceInfo stage) => RealSrcSpan -> AnnList d dom stage -> Maybe (Ann ValueBind dom stage) -getValBindInList sp ls = case ls ^? valBindsInList & filtered (isInside sp) of - [] -> Nothing - [n] -> Just n - _ -> error "getValBindInList: Multiple nodes" - -- | Get all nodes that contain a given source range nodesContaining :: (HasRange (inner dom stage), Biplate (node dom stage) (inner dom stage), SourceInfo stage) => RealSrcSpan -> Simple Traversal (node dom stage) (inner dom stage) @@ -158,11 +86,10 @@ nodesWithRange :: (Biplate (Ann node dom stage) (Ann inner dom stage), SourceInfo stage) => RealSrcSpan -> Simple Traversal (Ann node dom stage) (Ann inner dom stage) nodesWithRange rng = biplateRef & filtered (hasRange rng) - --- | True, if the node has the given range -hasRange :: SourceInfo stage => RealSrcSpan -> Ann inner dom stage -> Bool -hasRange rng node = case getRange node of RealSrcSpan sp -> sp == rng - _ -> False + where -- True, if the node has the given range + hasRange :: SourceInfo stage => RealSrcSpan -> Ann inner dom stage -> Bool + hasRange rng node = case getRange node of RealSrcSpan sp -> sp == rng + _ -> False -- | Get the shortest source range that contains the given getNodeContaining :: (Biplate (Ann node dom stage) (Ann inner dom stage), SourceInfo stage, HasRange (Ann inner dom stage)) @@ -171,16 +98,38 @@ [] -> Nothing results -> Just $ minimumBy (compareRangeLength `on` getRange) results --- | Compares two NESTED source spans based on their lengths +-- | Compares two source spans based on their lengths. Can only used for NESTED spans. compareRangeLength :: SrcSpan -> SrcSpan -> Ordering compareRangeLength (RealSrcSpan sp1) (RealSrcSpan sp2) = (lineDiff sp1 `compare` lineDiff sp2) `mappend` (colDiff sp1 `compare` colDiff sp2) where lineDiff sp = srcLocLine (realSrcSpanStart sp) - srcLocLine (realSrcSpanEnd sp) colDiff sp = srcLocCol (realSrcSpanStart sp) - srcLocCol (realSrcSpanEnd sp) -getNode :: (Biplate (Ann node dom stage) (Ann inner dom stage), SourceInfo stage) - => RealSrcSpan -> Ann node dom stage -> Ann inner dom stage -getNode sp node = case node ^? nodesWithRange sp of - [] -> error "getNode: The node cannot be found" - [n] -> n - _ -> error "getNode: Multiple nodes" +-- | A class to access the names of named elements. Have to locate where does the AST element store its name. +-- The returned name will be the one that was marked isDefining. +class NamedElement elem where + elementName :: Simple Traversal (Ann elem dom st) (Ann UQualifiedName dom st) + +instance NamedElement UDecl where + elementName = (declHead & declHeadNames) + &+& (declTypeFamily & tfHead & declHeadNames) + &+& (declValBind & bindingName) + &+& (declName & simpleName) + &+& (declPatSyn & patLhs & (patName & simpleName &+& patSynOp & operatorName)) + +instance NamedElement ULocalBind where + elementName = localVal&bindingName &+& localSig&tsName&annList&simpleName + +inScope :: GHC.Name -> Scope -> Bool +inScope n sc = any (n `elem`) sc + +-- * Pattern synonyms for annotated lists and maybes + +pattern AnnList :: [Ann elem dom stage] -> AnnListG elem dom stage +pattern AnnList elems <- AnnListG _ elems + +pattern AnnNothing :: AnnMaybeG elem dom stage +pattern AnnNothing <- AnnMaybeG _ Nothing + +pattern AnnJust :: Ann elem dom stage -> AnnMaybeG elem dom stage +pattern AnnJust elem <- AnnMaybeG _ (Just elem) diff --git a/Language/Haskell/Tools/AST/Instances/Data.hs b/Language/Haskell/Tools/AST/Instances/Data.hs --- a/Language/Haskell/Tools/AST/Instances/Data.hs +++ b/Language/Haskell/Tools/AST/Instances/Data.hs @@ -4,131 +4,131 @@ import Data.Data -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.TH -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Stmts -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.TH +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Stmts +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.Ann -- Annotations deriving instance (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (Ann e dom stage) -deriving instance (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnMaybe e dom stage) -deriving instance (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnList e dom stage) +deriving instance (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnMaybeG e dom stage) +deriving instance (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnListG e dom stage) -- Modules -deriving instance (Domain dom, SourceInfo stage) => Data (Module dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ModuleHead dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ExportSpecList dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ExportSpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (IESpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (SubSpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ModulePragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (FilePragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ImportDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ImportSpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ImportQualified dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ImportSource dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ImportSafe dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TypeNamespace dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ImportRenaming dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UModule dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UModuleHead dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UExportSpecs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UExportSpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UIESpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (USubSpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UModulePragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UFilePragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UImportDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UImportSpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UImportQualified dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UImportSource dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UImportSafe dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTypeNamespace dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UImportRenaming dom stage) -- Declarations -deriving instance (Domain dom, SourceInfo stage) => Data (Decl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ClassBody dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ClassElement dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (DeclHead dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (InstBody dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (InstBodyDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (GadtConDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (GadtConType dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (FieldWildcard dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (FunDeps dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (FunDep dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ConDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (FieldDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Deriving dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (InstanceRule dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (InstanceHead dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TypeEqn dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (KindConstraint dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TyVar dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Type dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Kind dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Context dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Assertion dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Expr dom stage) -deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (Stmt' expr dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (CompStmt dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ValueBind dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Pattern dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (PatternField dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Splice dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UClassBody dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UClassElement dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UDeclHead dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UInstBody dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UInstBodyDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UGadtConDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UGadtConType dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UFieldWildcard dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UFunDeps dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UFunDep dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UConDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UFieldDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UDeriving dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UInstanceRule dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UInstanceHead dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTypeEqn dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UKindConstraint dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTyVar dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UType dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UKind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UContext dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UAssertion dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UExpr dom stage) +deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (UStmt' expr dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UCompStmt dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UValueBind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPattern dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPatternField dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (USplice dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (QQString dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Match dom stage) -deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (Alt' expr dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Rhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (GuardedRhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (FieldUpdate dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Bracket dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TopLevelPragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Rule dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (AnnotationSubject dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (MinimalFormula dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ExprPragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (SourceRange dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UMatch dom stage) +deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (UAlt' expr dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (URhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UGuardedRhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UFieldUpdate dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UBracket dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTopLevelPragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (URule dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UAnnotationSubject dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UMinimalFormula dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UExprPragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (USourceRange dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (Number dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (QuasiQuote dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (RhsGuard dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (LocalBind dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (LocalBinds dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (FixitySignature dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TypeSignature dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ListCompBody dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TupSecElem dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TypeFamily dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (TypeFamilySpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (InjectivityAnn dom stage) -deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (CaseRhs' expr dom stage) -deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage))=> Data (GuardedCaseRhs' expr dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (PatternSynonym dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (PatSynRhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (PatSynLhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (PatSynWhere dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (PatternTypeSignature dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Role dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Cmd dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (LanguageExtension dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (MatchLhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UQuasiQuote dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (URhsGuard dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (ULocalBind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (ULocalBinds dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UFixitySignature dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTypeSignature dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UListCompBody dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTupSecElem dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTypeFamily dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UTypeFamilySpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UInjectivityAnn dom stage) +deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage)) => Data (UCaseRhs' expr dom stage) +deriving instance (DomainWith expr dom, SourceInfo stage, Typeable expr, Data (expr dom stage))=> Data (UGuardedCaseRhs' expr dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPatternSynonym dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPatSynRhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPatSynLhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPatSynWhere dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPatternTypeSignature dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (URole dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UCmd dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (ULanguageExtension dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UMatchLhs dom stage) --- Literal -deriving instance (Domain dom, SourceInfo stage) => Data (Literal dom stage) -deriving instance (DomainWith k dom, SourceInfo stage, Typeable k, Data (k dom stage)) => Data (Promoted k dom stage) +-- ULiteral +deriving instance (Domain dom, SourceInfo stage) => Data (ULiteral dom stage) +deriving instance (DomainWith k dom, SourceInfo stage, Typeable k, Data (k dom stage)) => Data (UPromoted k dom stage) -- Base -deriving instance (Domain dom, SourceInfo stage) => Data (Operator dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Name dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (QualifiedName dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ModuleName dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (UnqualName dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (StringNode dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (DataOrNewtypeKeyword dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (DoKind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UOperator dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UName dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UQualifiedName dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UModuleName dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UNamePart dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UStringNode dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UDataOrNewtypeKeyword dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UDoKind dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (TypeKeyword dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (OverlapPragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (CallConv dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ArrowAppl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (Safety dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (ConlikeAnnot dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UOverlapPragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UCallConv dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UArrowAppl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (USafety dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UConlikeAnnot dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (Assoc dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (Precedence dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (LineNumber dom stage) -deriving instance (Domain dom, SourceInfo stage) => Data (PhaseControl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Data (UPhaseControl dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (PhaseNumber dom stage) deriving instance (Domain dom, SourceInfo stage) => Data (PhaseInvert dom stage) diff --git a/Language/Haskell/Tools/AST/Instances/Eq.hs b/Language/Haskell/Tools/AST/Instances/Eq.hs --- a/Language/Haskell/Tools/AST/Instances/Eq.hs +++ b/Language/Haskell/Tools/AST/Instances/Eq.hs @@ -2,136 +2,136 @@ {-# LANGUAGE FlexibleContexts, StandaloneDeriving #-} module Language.Haskell.Tools.AST.Instances.Eq where -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.TH -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Stmts -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.TH +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Stmts +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.Ann -- Annotations instance (Eq (e dom stage)) => Eq (Ann e dom stage) where Ann _ e1 == Ann _ e2 = e1 == e2 -instance (Eq (e dom stage)) => Eq (AnnMaybe e dom stage) where - AnnMaybe _ e1 == AnnMaybe _ e2 = e1 == e2 +instance (Eq (e dom stage)) => Eq (AnnMaybeG e dom stage) where + AnnMaybeG _ e1 == AnnMaybeG _ e2 = e1 == e2 -instance (Eq (e dom stage)) => Eq (AnnList e dom stage) where - AnnList _ e1 == AnnList _ e2 = e1 == e2 +instance (Eq (e dom stage)) => Eq (AnnListG e dom stage) where + AnnListG _ e1 == AnnListG _ e2 = e1 == e2 -- Modules -deriving instance Eq (Module dom stage) -deriving instance Eq (ModuleHead dom stage) -deriving instance Eq (ExportSpecList dom stage) -deriving instance Eq (ExportSpec dom stage) -deriving instance Eq (IESpec dom stage) -deriving instance Eq (SubSpec dom stage) -deriving instance Eq (ModulePragma dom stage) -deriving instance Eq (FilePragma dom stage) -deriving instance Eq (ImportDecl dom stage) -deriving instance Eq (ImportSpec dom stage) -deriving instance Eq (ImportQualified dom stage) -deriving instance Eq (ImportSource dom stage) -deriving instance Eq (ImportSafe dom stage) -deriving instance Eq (TypeNamespace dom stage) -deriving instance Eq (ImportRenaming dom stage) +deriving instance Eq (UModule dom stage) +deriving instance Eq (UModuleHead dom stage) +deriving instance Eq (UExportSpecs dom stage) +deriving instance Eq (UExportSpec dom stage) +deriving instance Eq (UIESpec dom stage) +deriving instance Eq (USubSpec dom stage) +deriving instance Eq (UModulePragma dom stage) +deriving instance Eq (UFilePragma dom stage) +deriving instance Eq (UImportDecl dom stage) +deriving instance Eq (UImportSpec dom stage) +deriving instance Eq (UImportQualified dom stage) +deriving instance Eq (UImportSource dom stage) +deriving instance Eq (UImportSafe dom stage) +deriving instance Eq (UTypeNamespace dom stage) +deriving instance Eq (UImportRenaming dom stage) -- Declarations -deriving instance Eq (Decl dom stage) -deriving instance Eq (ClassBody dom stage) -deriving instance Eq (ClassElement dom stage) -deriving instance Eq (DeclHead dom stage) -deriving instance Eq (InstBody dom stage) -deriving instance Eq (InstBodyDecl dom stage) -deriving instance Eq (GadtConDecl dom stage) -deriving instance Eq (GadtConType dom stage) -deriving instance Eq (FieldWildcard dom stage) -deriving instance Eq (FunDeps dom stage) -deriving instance Eq (FunDep dom stage) -deriving instance Eq (ConDecl dom stage) -deriving instance Eq (FieldDecl dom stage) -deriving instance Eq (Deriving dom stage) -deriving instance Eq (InstanceRule dom stage) -deriving instance Eq (InstanceHead dom stage) -deriving instance Eq (TypeEqn dom stage) -deriving instance Eq (KindConstraint dom stage) -deriving instance Eq (TyVar dom stage) -deriving instance Eq (Type dom stage) -deriving instance Eq (Kind dom stage) -deriving instance Eq (Context dom stage) -deriving instance Eq (Assertion dom stage) -deriving instance Eq (Expr dom stage) -deriving instance Eq (expr dom stage) => Eq (Stmt' expr dom stage) -deriving instance Eq (CompStmt dom stage) -deriving instance Eq (ValueBind dom stage) -deriving instance Eq (Pattern dom stage) -deriving instance Eq (PatternField dom stage) -deriving instance Eq (Splice dom stage) +deriving instance Eq (UDecl dom stage) +deriving instance Eq (UClassBody dom stage) +deriving instance Eq (UClassElement dom stage) +deriving instance Eq (UDeclHead dom stage) +deriving instance Eq (UInstBody dom stage) +deriving instance Eq (UInstBodyDecl dom stage) +deriving instance Eq (UGadtConDecl dom stage) +deriving instance Eq (UGadtConType dom stage) +deriving instance Eq (UFieldWildcard dom stage) +deriving instance Eq (UFunDeps dom stage) +deriving instance Eq (UFunDep dom stage) +deriving instance Eq (UConDecl dom stage) +deriving instance Eq (UFieldDecl dom stage) +deriving instance Eq (UDeriving dom stage) +deriving instance Eq (UInstanceRule dom stage) +deriving instance Eq (UInstanceHead dom stage) +deriving instance Eq (UTypeEqn dom stage) +deriving instance Eq (UKindConstraint dom stage) +deriving instance Eq (UTyVar dom stage) +deriving instance Eq (UType dom stage) +deriving instance Eq (UKind dom stage) +deriving instance Eq (UContext dom stage) +deriving instance Eq (UAssertion dom stage) +deriving instance Eq (UExpr dom stage) +deriving instance Eq (expr dom stage) => Eq (UStmt' expr dom stage) +deriving instance Eq (UCompStmt dom stage) +deriving instance Eq (UValueBind dom stage) +deriving instance Eq (UPattern dom stage) +deriving instance Eq (UPatternField dom stage) +deriving instance Eq (USplice dom stage) deriving instance Eq (QQString dom stage) -deriving instance Eq (Match dom stage) -deriving instance Eq (expr dom stage) => Eq (Alt' expr dom stage) -deriving instance Eq (Rhs dom stage) -deriving instance Eq (GuardedRhs dom stage) -deriving instance Eq (FieldUpdate dom stage) -deriving instance Eq (Bracket dom stage) -deriving instance Eq (TopLevelPragma dom stage) -deriving instance Eq (Rule dom stage) -deriving instance Eq (AnnotationSubject dom stage) -deriving instance Eq (MinimalFormula dom stage) -deriving instance Eq (ExprPragma dom stage) -deriving instance Eq (SourceRange dom stage) +deriving instance Eq (UMatch dom stage) +deriving instance Eq (expr dom stage) => Eq (UAlt' expr dom stage) +deriving instance Eq (URhs dom stage) +deriving instance Eq (UGuardedRhs dom stage) +deriving instance Eq (UFieldUpdate dom stage) +deriving instance Eq (UBracket dom stage) +deriving instance Eq (UTopLevelPragma dom stage) +deriving instance Eq (URule dom stage) +deriving instance Eq (UAnnotationSubject dom stage) +deriving instance Eq (UMinimalFormula dom stage) +deriving instance Eq (UExprPragma dom stage) +deriving instance Eq (USourceRange dom stage) deriving instance Eq (Number dom stage) -deriving instance Eq (QuasiQuote dom stage) -deriving instance Eq (RhsGuard dom stage) -deriving instance Eq (LocalBind dom stage) -deriving instance Eq (LocalBinds dom stage) -deriving instance Eq (FixitySignature dom stage) -deriving instance Eq (TypeSignature dom stage) -deriving instance Eq (ListCompBody dom stage) -deriving instance Eq (TupSecElem dom stage) -deriving instance Eq (TypeFamily dom stage) -deriving instance Eq (TypeFamilySpec dom stage) -deriving instance Eq (InjectivityAnn dom stage) -deriving instance Eq (expr dom stage) => Eq (CaseRhs' expr dom stage) -deriving instance Eq (expr dom stage) => Eq (GuardedCaseRhs' expr dom stage) -deriving instance Eq (PatternSynonym dom stage) -deriving instance Eq (PatSynRhs dom stage) -deriving instance Eq (PatSynLhs dom stage) -deriving instance Eq (PatSynWhere dom stage) -deriving instance Eq (PatternTypeSignature dom stage) -deriving instance Eq (Role dom stage) -deriving instance Eq (Cmd dom stage) -deriving instance Eq (LanguageExtension dom stage) -deriving instance Eq (MatchLhs dom stage) +deriving instance Eq (UQuasiQuote dom stage) +deriving instance Eq (URhsGuard dom stage) +deriving instance Eq (ULocalBind dom stage) +deriving instance Eq (ULocalBinds dom stage) +deriving instance Eq (UFixitySignature dom stage) +deriving instance Eq (UTypeSignature dom stage) +deriving instance Eq (UListCompBody dom stage) +deriving instance Eq (UTupSecElem dom stage) +deriving instance Eq (UTypeFamily dom stage) +deriving instance Eq (UTypeFamilySpec dom stage) +deriving instance Eq (UInjectivityAnn dom stage) +deriving instance Eq (expr dom stage) => Eq (UCaseRhs' expr dom stage) +deriving instance Eq (expr dom stage) => Eq (UGuardedCaseRhs' expr dom stage) +deriving instance Eq (UPatternSynonym dom stage) +deriving instance Eq (UPatSynRhs dom stage) +deriving instance Eq (UPatSynLhs dom stage) +deriving instance Eq (UPatSynWhere dom stage) +deriving instance Eq (UPatternTypeSignature dom stage) +deriving instance Eq (URole dom stage) +deriving instance Eq (UCmd dom stage) +deriving instance Eq (ULanguageExtension dom stage) +deriving instance Eq (UMatchLhs dom stage) --- Literal -deriving instance Eq (Literal dom stage) -deriving instance Eq (k dom stage) => Eq (Promoted k dom stage) +-- ULiteral +deriving instance Eq (ULiteral dom stage) +deriving instance Eq (k dom stage) => Eq (UPromoted k dom stage) -- Base -deriving instance Eq (Operator dom stage) -deriving instance Eq (Name dom stage) -deriving instance Eq (QualifiedName dom stage) -deriving instance Eq (ModuleName dom stage) -deriving instance Eq (UnqualName dom stage) -deriving instance Eq (StringNode dom stage) -deriving instance Eq (DataOrNewtypeKeyword dom stage) -deriving instance Eq (DoKind dom stage) +deriving instance Eq (UOperator dom stage) +deriving instance Eq (UName dom stage) +deriving instance Eq (UQualifiedName dom stage) +deriving instance Eq (UModuleName dom stage) +deriving instance Eq (UNamePart dom stage) +deriving instance Eq (UStringNode dom stage) +deriving instance Eq (UDataOrNewtypeKeyword dom stage) +deriving instance Eq (UDoKind dom stage) deriving instance Eq (TypeKeyword dom stage) -deriving instance Eq (OverlapPragma dom stage) -deriving instance Eq (CallConv dom stage) -deriving instance Eq (ArrowAppl dom stage) -deriving instance Eq (Safety dom stage) -deriving instance Eq (ConlikeAnnot dom stage) +deriving instance Eq (UOverlapPragma dom stage) +deriving instance Eq (UCallConv dom stage) +deriving instance Eq (UArrowAppl dom stage) +deriving instance Eq (USafety dom stage) +deriving instance Eq (UConlikeAnnot dom stage) deriving instance Eq (Assoc dom stage) deriving instance Eq (Precedence dom stage) deriving instance Eq (LineNumber dom stage) -deriving instance Eq (PhaseControl dom stage) +deriving instance Eq (UPhaseControl dom stage) deriving instance Eq (PhaseNumber dom stage) deriving instance Eq (PhaseInvert dom stage) diff --git a/Language/Haskell/Tools/AST/Instances/Generic.hs b/Language/Haskell/Tools/AST/Instances/Generic.hs --- a/Language/Haskell/Tools/AST/Instances/Generic.hs +++ b/Language/Haskell/Tools/AST/Instances/Generic.hs @@ -4,132 +4,132 @@ import GHC.Generics -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.TH -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Stmts -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.TH +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Stmts +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.Ann -- Annotations deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (Ann e dom stage) -deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (AnnMaybe e dom stage) -deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (AnnList e dom stage) +deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (AnnMaybeG e dom stage) +deriving instance (Domain dom, SourceInfo stage, Generic (e dom stage)) => Generic (AnnListG e dom stage) -- Modules -deriving instance (Domain dom, SourceInfo stage) => Generic (Module dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ModuleHead dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ExportSpecList dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ExportSpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (IESpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (SubSpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ModulePragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (FilePragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ImportDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ImportSpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ImportQualified dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ImportSource dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ImportSafe dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TypeNamespace dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ImportRenaming dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UModule dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UModuleHead dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UExportSpecs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UExportSpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UIESpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (USubSpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UModulePragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UFilePragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UImportDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UImportSpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UImportQualified dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UImportSource dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UImportSafe dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeNamespace dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UImportRenaming dom stage) -- Declarations -deriving instance (Domain dom, SourceInfo stage) => Generic (Decl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ClassBody dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ClassElement dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (DeclHead dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (InstBody dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (InstBodyDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (GadtConDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (GadtConType dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (FieldWildcard dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (FunDeps dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (FunDep dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ConDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (FieldDecl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Deriving dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (InstanceRule dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (InstanceHead dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TypeEqn dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (KindConstraint dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TyVar dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Type dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Kind dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Context dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Assertion dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Expr dom stage) -deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (Stmt' expr dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (CompStmt dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ValueBind dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Pattern dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (PatternField dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Splice dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UClassBody dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UClassElement dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UDeclHead dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UInstBody dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UInstBodyDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UGadtConDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UGadtConType dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UFieldWildcard dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UFunDeps dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UFunDep dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UConDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UFieldDecl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UDeriving dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UInstanceRule dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UInstanceHead dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeEqn dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UKindConstraint dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTyVar dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UType dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UKind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UContext dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UAssertion dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UExpr dom stage) +deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UStmt' expr dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UCompStmt dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UValueBind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPattern dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPatternField dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (USplice dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (QQString dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Match dom stage) -deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (Alt' expr dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Rhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (GuardedRhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (FieldUpdate dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Bracket dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TopLevelPragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Rule dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (AnnotationSubject dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (MinimalFormula dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ExprPragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (SourceRange dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UMatch dom stage) +deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UAlt' expr dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (URhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UGuardedRhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UFieldUpdate dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UBracket dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTopLevelPragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (URule dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UAnnotationSubject dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UMinimalFormula dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UExprPragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (USourceRange dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (Number dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (QuasiQuote dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (RhsGuard dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (LocalBind dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (LocalBinds dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (FixitySignature dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TypeSignature dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ListCompBody dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TupSecElem dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TypeFamily dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (TypeFamilySpec dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (InjectivityAnn dom stage) -deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (CaseRhs' expr dom stage) -deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (GuardedCaseRhs' expr dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (PatternSynonym dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (PatSynRhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (PatSynLhs dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (PatSynWhere dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (PatternTypeSignature dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Role dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Cmd dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (LanguageExtension dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (MatchLhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UQuasiQuote dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (URhsGuard dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (ULocalBind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (ULocalBinds dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UFixitySignature dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeSignature dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UListCompBody dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTupSecElem dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeFamily dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UTypeFamilySpec dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UInjectivityAnn dom stage) +deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UCaseRhs' expr dom stage) +deriving instance (Domain dom, SourceInfo stage, Generic (expr dom stage)) => Generic (UGuardedCaseRhs' expr dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPatternSynonym dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPatSynRhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPatSynLhs dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPatSynWhere dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPatternTypeSignature dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (URole dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UCmd dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (ULanguageExtension dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UMatchLhs dom stage) --- Literal -deriving instance (Domain dom, SourceInfo stage) => Generic (Literal dom stage) -deriving instance (Domain dom, SourceInfo stage, Generic (k dom stage)) => Generic (Promoted k dom stage) +-- ULiteral +deriving instance (Domain dom, SourceInfo stage) => Generic (ULiteral dom stage) +deriving instance (Domain dom, SourceInfo stage, Generic (k dom stage)) => Generic (UPromoted k dom stage) -- Base -deriving instance (Domain dom, SourceInfo stage) => Generic (Operator dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Name dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (QualifiedName dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ModuleName dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (UnqualName dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (StringNode dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (DataOrNewtypeKeyword dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (DoKind dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UOperator dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UName dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UQualifiedName dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UModuleName dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UNamePart dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UStringNode dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UDataOrNewtypeKeyword dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UDoKind dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (TypeKeyword dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (OverlapPragma dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (CallConv dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ArrowAppl dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (Safety dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (ConlikeAnnot dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UOverlapPragma dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UCallConv dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UArrowAppl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (USafety dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UConlikeAnnot dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (Assoc dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (Precedence dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (LineNumber dom stage) -deriving instance (Domain dom, SourceInfo stage) => Generic (PhaseControl dom stage) +deriving instance (Domain dom, SourceInfo stage) => Generic (UPhaseControl dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (PhaseNumber dom stage) deriving instance (Domain dom, SourceInfo stage) => Generic (PhaseInvert dom stage) diff --git a/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs b/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs --- a/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs +++ b/Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs @@ -6,127 +6,127 @@ import Language.Haskell.Tools.AST.TH.SemanticTraversal import Control.Applicative -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.TH -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Stmts -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.TH +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Stmts +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.Ann -- Modules -deriveSemanticTraversal ''Module -deriveSemanticTraversal ''ModuleHead -deriveSemanticTraversal ''ExportSpecList -deriveSemanticTraversal ''ExportSpec -deriveSemanticTraversal ''IESpec -deriveSemanticTraversal ''SubSpec -deriveSemanticTraversal ''ModulePragma -deriveSemanticTraversal ''FilePragma -deriveSemanticTraversal ''ImportDecl -deriveSemanticTraversal ''ImportSpec -deriveSemanticTraversal ''ImportQualified -deriveSemanticTraversal ''ImportSource -deriveSemanticTraversal ''ImportSafe -deriveSemanticTraversal ''TypeNamespace -deriveSemanticTraversal ''ImportRenaming +deriveSemanticTraversal ''UModule +deriveSemanticTraversal ''UModuleHead +deriveSemanticTraversal ''UExportSpecs +deriveSemanticTraversal ''UExportSpec +deriveSemanticTraversal ''UIESpec +deriveSemanticTraversal ''USubSpec +deriveSemanticTraversal ''UModulePragma +deriveSemanticTraversal ''UFilePragma +deriveSemanticTraversal ''UImportDecl +deriveSemanticTraversal ''UImportSpec +deriveSemanticTraversal ''UImportQualified +deriveSemanticTraversal ''UImportSource +deriveSemanticTraversal ''UImportSafe +deriveSemanticTraversal ''UTypeNamespace +deriveSemanticTraversal ''UImportRenaming -- Declarations -deriveSemanticTraversal ''Decl -deriveSemanticTraversal ''ClassBody -deriveSemanticTraversal ''ClassElement -deriveSemanticTraversal ''DeclHead -deriveSemanticTraversal ''InstBody -deriveSemanticTraversal ''InstBodyDecl -deriveSemanticTraversal ''GadtConDecl -deriveSemanticTraversal ''GadtConType -deriveSemanticTraversal ''FieldWildcard -deriveSemanticTraversal ''FunDeps -deriveSemanticTraversal ''FunDep -deriveSemanticTraversal ''ConDecl -deriveSemanticTraversal ''FieldDecl -deriveSemanticTraversal ''Deriving -deriveSemanticTraversal ''InstanceRule -deriveSemanticTraversal ''InstanceHead -deriveSemanticTraversal ''TypeEqn -deriveSemanticTraversal ''KindConstraint -deriveSemanticTraversal ''TyVar -deriveSemanticTraversal ''Type -deriveSemanticTraversal ''Kind -deriveSemanticTraversal ''Context -deriveSemanticTraversal ''Assertion -deriveSemanticTraversal ''Expr -deriveSemanticTraversal ''CompStmt -deriveSemanticTraversal ''ValueBind -deriveSemanticTraversal ''Pattern -deriveSemanticTraversal ''PatternField -deriveSemanticTraversal ''Splice +deriveSemanticTraversal ''UDecl +deriveSemanticTraversal ''UClassBody +deriveSemanticTraversal ''UClassElement +deriveSemanticTraversal ''UDeclHead +deriveSemanticTraversal ''UInstBody +deriveSemanticTraversal ''UInstBodyDecl +deriveSemanticTraversal ''UGadtConDecl +deriveSemanticTraversal ''UGadtConType +deriveSemanticTraversal ''UFieldWildcard +deriveSemanticTraversal ''UFunDeps +deriveSemanticTraversal ''UFunDep +deriveSemanticTraversal ''UConDecl +deriveSemanticTraversal ''UFieldDecl +deriveSemanticTraversal ''UDeriving +deriveSemanticTraversal ''UInstanceRule +deriveSemanticTraversal ''UInstanceHead +deriveSemanticTraversal ''UTypeEqn +deriveSemanticTraversal ''UKindConstraint +deriveSemanticTraversal ''UTyVar +deriveSemanticTraversal ''UType +deriveSemanticTraversal ''UKind +deriveSemanticTraversal ''UContext +deriveSemanticTraversal ''UAssertion +deriveSemanticTraversal ''UExpr +deriveSemanticTraversal ''UCompStmt +deriveSemanticTraversal ''UValueBind +deriveSemanticTraversal ''UPattern +deriveSemanticTraversal ''UPatternField +deriveSemanticTraversal ''USplice deriveSemanticTraversal ''QQString -deriveSemanticTraversal ''Match -deriveSemanticTraversal ''Rhs -deriveSemanticTraversal ''GuardedRhs -deriveSemanticTraversal ''FieldUpdate -deriveSemanticTraversal ''Bracket -deriveSemanticTraversal ''TopLevelPragma -deriveSemanticTraversal ''Rule -deriveSemanticTraversal ''AnnotationSubject -deriveSemanticTraversal ''MinimalFormula -deriveSemanticTraversal ''ExprPragma -deriveSemanticTraversal ''SourceRange +deriveSemanticTraversal ''UMatch +deriveSemanticTraversal ''URhs +deriveSemanticTraversal ''UGuardedRhs +deriveSemanticTraversal ''UFieldUpdate +deriveSemanticTraversal ''UBracket +deriveSemanticTraversal ''UTopLevelPragma +deriveSemanticTraversal ''URule +deriveSemanticTraversal ''UAnnotationSubject +deriveSemanticTraversal ''UMinimalFormula +deriveSemanticTraversal ''UExprPragma +deriveSemanticTraversal ''USourceRange deriveSemanticTraversal ''Number -deriveSemanticTraversal ''QuasiQuote -deriveSemanticTraversal ''RhsGuard -deriveSemanticTraversal ''LocalBind -deriveSemanticTraversal ''LocalBinds -deriveSemanticTraversal ''FixitySignature -deriveSemanticTraversal ''TypeSignature -deriveSemanticTraversal ''ListCompBody -deriveSemanticTraversal ''TupSecElem -deriveSemanticTraversal ''TypeFamily -deriveSemanticTraversal ''TypeFamilySpec -deriveSemanticTraversal ''InjectivityAnn -deriveSemanticTraversal ''PatternSynonym -deriveSemanticTraversal ''PatSynRhs -deriveSemanticTraversal ''PatSynLhs -deriveSemanticTraversal ''PatSynWhere -deriveSemanticTraversal ''PatternTypeSignature -deriveSemanticTraversal ''Role -deriveSemanticTraversal ''Cmd -deriveSemanticTraversal ''LanguageExtension -deriveSemanticTraversal ''MatchLhs -deriveSemanticTraversal ''Stmt' -deriveSemanticTraversal ''Alt' -deriveSemanticTraversal ''CaseRhs' -deriveSemanticTraversal ''GuardedCaseRhs' +deriveSemanticTraversal ''UQuasiQuote +deriveSemanticTraversal ''URhsGuard +deriveSemanticTraversal ''ULocalBind +deriveSemanticTraversal ''ULocalBinds +deriveSemanticTraversal ''UFixitySignature +deriveSemanticTraversal ''UTypeSignature +deriveSemanticTraversal ''UListCompBody +deriveSemanticTraversal ''UTupSecElem +deriveSemanticTraversal ''UTypeFamily +deriveSemanticTraversal ''UTypeFamilySpec +deriveSemanticTraversal ''UInjectivityAnn +deriveSemanticTraversal ''UPatternSynonym +deriveSemanticTraversal ''UPatSynRhs +deriveSemanticTraversal ''UPatSynLhs +deriveSemanticTraversal ''UPatSynWhere +deriveSemanticTraversal ''UPatternTypeSignature +deriveSemanticTraversal ''URole +deriveSemanticTraversal ''UCmd +deriveSemanticTraversal ''ULanguageExtension +deriveSemanticTraversal ''UMatchLhs +deriveSemanticTraversal ''UStmt' +deriveSemanticTraversal ''UAlt' +deriveSemanticTraversal ''UCaseRhs' +deriveSemanticTraversal ''UGuardedCaseRhs' --- Literal -deriveSemanticTraversal ''Literal -deriveSemanticTraversal ''Promoted +-- ULiteral +deriveSemanticTraversal ''ULiteral +deriveSemanticTraversal ''UPromoted -- Base -deriveSemanticTraversal ''Operator -deriveSemanticTraversal ''Name -deriveSemanticTraversal ''QualifiedName -deriveSemanticTraversal ''ModuleName -deriveSemanticTraversal ''UnqualName -deriveSemanticTraversal ''StringNode -deriveSemanticTraversal ''DataOrNewtypeKeyword -deriveSemanticTraversal ''DoKind +deriveSemanticTraversal ''UOperator +deriveSemanticTraversal ''UName +deriveSemanticTraversal ''UQualifiedName +deriveSemanticTraversal ''UModuleName +deriveSemanticTraversal ''UNamePart +deriveSemanticTraversal ''UStringNode +deriveSemanticTraversal ''UDataOrNewtypeKeyword +deriveSemanticTraversal ''UDoKind deriveSemanticTraversal ''TypeKeyword -deriveSemanticTraversal ''OverlapPragma -deriveSemanticTraversal ''CallConv -deriveSemanticTraversal ''ArrowAppl -deriveSemanticTraversal ''Safety -deriveSemanticTraversal ''ConlikeAnnot +deriveSemanticTraversal ''UOverlapPragma +deriveSemanticTraversal ''UCallConv +deriveSemanticTraversal ''UArrowAppl +deriveSemanticTraversal ''USafety +deriveSemanticTraversal ''UConlikeAnnot deriveSemanticTraversal ''Assoc deriveSemanticTraversal ''Precedence deriveSemanticTraversal ''LineNumber -deriveSemanticTraversal ''PhaseControl +deriveSemanticTraversal ''UPhaseControl deriveSemanticTraversal ''PhaseNumber deriveSemanticTraversal ''PhaseInvert diff --git a/Language/Haskell/Tools/AST/Instances/Show.hs b/Language/Haskell/Tools/AST/Instances/Show.hs --- a/Language/Haskell/Tools/AST/Instances/Show.hs +++ b/Language/Haskell/Tools/AST/Instances/Show.hs @@ -2,137 +2,137 @@ {-# LANGUAGE FlexibleContexts, StandaloneDeriving #-} module Language.Haskell.Tools.AST.Instances.Show where -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.TH -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Stmts -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.TH +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Stmts +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.Ann -- Annotations instance (Show (e dom stage)) => Show (Ann e dom stage) where show (Ann _ e) = show e -instance (Show (e dom stage)) => Show (AnnMaybe e dom stage) where - show (AnnMaybe _ e) = show e +instance (Show (e dom stage)) => Show (AnnMaybeG e dom stage) where + show (AnnMaybeG _ e) = show e -instance (Show (e dom stage)) => Show (AnnList e dom stage) where - show (AnnList _ e) = show e +instance (Show (e dom stage)) => Show (AnnListG e dom stage) where + show (AnnListG _ e) = show e -- Modules -deriving instance Show (Module dom stage) -deriving instance Show (ModuleHead dom stage) -deriving instance Show (ExportSpecList dom stage) -deriving instance Show (ExportSpec dom stage) -deriving instance Show (IESpec dom stage) -deriving instance Show (SubSpec dom stage) -deriving instance Show (ModulePragma dom stage) -deriving instance Show (FilePragma dom stage) -deriving instance Show (ImportDecl dom stage) -deriving instance Show (ImportSpec dom stage) -deriving instance Show (ImportQualified dom stage) -deriving instance Show (ImportSource dom stage) -deriving instance Show (ImportSafe dom stage) -deriving instance Show (TypeNamespace dom stage) -deriving instance Show (ImportRenaming dom stage) +deriving instance Show (UModule dom stage) +deriving instance Show (UModuleHead dom stage) +deriving instance Show (UExportSpecs dom stage) +deriving instance Show (UExportSpec dom stage) +deriving instance Show (UIESpec dom stage) +deriving instance Show (USubSpec dom stage) +deriving instance Show (UModulePragma dom stage) +deriving instance Show (UFilePragma dom stage) +deriving instance Show (UImportDecl dom stage) +deriving instance Show (UImportSpec dom stage) +deriving instance Show (UImportQualified dom stage) +deriving instance Show (UImportSource dom stage) +deriving instance Show (UImportSafe dom stage) +deriving instance Show (UTypeNamespace dom stage) +deriving instance Show (UImportRenaming dom stage) -- Declarations -deriving instance Show (Decl dom stage) -deriving instance Show (ClassBody dom stage) -deriving instance Show (ClassElement dom stage) -deriving instance Show (DeclHead dom stage) -deriving instance Show (InstBody dom stage) -deriving instance Show (InstBodyDecl dom stage) -deriving instance Show (GadtConDecl dom stage) -deriving instance Show (GadtConType dom stage) -deriving instance Show (FieldWildcard dom stage) -deriving instance Show (FunDeps dom stage) -deriving instance Show (FunDep dom stage) -deriving instance Show (ConDecl dom stage) -deriving instance Show (FieldDecl dom stage) -deriving instance Show (Deriving dom stage) -deriving instance Show (InstanceRule dom stage) -deriving instance Show (InstanceHead dom stage) -deriving instance Show (TypeEqn dom stage) -deriving instance Show (KindConstraint dom stage) -deriving instance Show (TyVar dom stage) -deriving instance Show (Type dom stage) -deriving instance Show (Kind dom stage) -deriving instance Show (Context dom stage) -deriving instance Show (Assertion dom stage) -deriving instance Show (Expr dom stage) -deriving instance Show (expr dom stage) => Show (Stmt' expr dom stage) -deriving instance Show (CompStmt dom stage) -deriving instance Show (ValueBind dom stage) -deriving instance Show (Pattern dom stage) -deriving instance Show (PatternField dom stage) -deriving instance Show (Splice dom stage) +deriving instance Show (UDecl dom stage) +deriving instance Show (UClassBody dom stage) +deriving instance Show (UClassElement dom stage) +deriving instance Show (UDeclHead dom stage) +deriving instance Show (UInstBody dom stage) +deriving instance Show (UInstBodyDecl dom stage) +deriving instance Show (UGadtConDecl dom stage) +deriving instance Show (UGadtConType dom stage) +deriving instance Show (UFieldWildcard dom stage) +deriving instance Show (UFunDeps dom stage) +deriving instance Show (UFunDep dom stage) +deriving instance Show (UConDecl dom stage) +deriving instance Show (UFieldDecl dom stage) +deriving instance Show (UDeriving dom stage) +deriving instance Show (UInstanceRule dom stage) +deriving instance Show (UInstanceHead dom stage) +deriving instance Show (UTypeEqn dom stage) +deriving instance Show (UKindConstraint dom stage) +deriving instance Show (UTyVar dom stage) +deriving instance Show (UType dom stage) +deriving instance Show (UKind dom stage) +deriving instance Show (UContext dom stage) +deriving instance Show (UAssertion dom stage) +deriving instance Show (UExpr dom stage) +deriving instance Show (expr dom stage) => Show (UStmt' expr dom stage) +deriving instance Show (UCompStmt dom stage) +deriving instance Show (UValueBind dom stage) +deriving instance Show (UPattern dom stage) +deriving instance Show (UPatternField dom stage) +deriving instance Show (USplice dom stage) deriving instance Show (QQString dom stage) -deriving instance Show (Match dom stage) -deriving instance Show (expr dom stage) => Show (Alt' expr dom stage) -deriving instance Show (Rhs dom stage) -deriving instance Show (GuardedRhs dom stage) -deriving instance Show (FieldUpdate dom stage) -deriving instance Show (Bracket dom stage) -deriving instance Show (TopLevelPragma dom stage) -deriving instance Show (Rule dom stage) -deriving instance Show (AnnotationSubject dom stage) -deriving instance Show (MinimalFormula dom stage) -deriving instance Show (ExprPragma dom stage) -deriving instance Show (SourceRange dom stage) +deriving instance Show (UMatch dom stage) +deriving instance Show (expr dom stage) => Show (UAlt' expr dom stage) +deriving instance Show (URhs dom stage) +deriving instance Show (UGuardedRhs dom stage) +deriving instance Show (UFieldUpdate dom stage) +deriving instance Show (UBracket dom stage) +deriving instance Show (UTopLevelPragma dom stage) +deriving instance Show (URule dom stage) +deriving instance Show (UAnnotationSubject dom stage) +deriving instance Show (UMinimalFormula dom stage) +deriving instance Show (UExprPragma dom stage) +deriving instance Show (USourceRange dom stage) deriving instance Show (Number dom stage) -deriving instance Show (QuasiQuote dom stage) -deriving instance Show (RhsGuard dom stage) -deriving instance Show (LocalBind dom stage) -deriving instance Show (LocalBinds dom stage) -deriving instance Show (FixitySignature dom stage) -deriving instance Show (TypeSignature dom stage) -deriving instance Show (ListCompBody dom stage) -deriving instance Show (TupSecElem dom stage) -deriving instance Show (TypeFamily dom stage) -deriving instance Show (TypeFamilySpec dom stage) -deriving instance Show (InjectivityAnn dom stage) -deriving instance Show (expr dom stage) => Show (CaseRhs' expr dom stage) -deriving instance Show (expr dom stage) => Show (GuardedCaseRhs' expr dom stage) -deriving instance Show (PatternSynonym dom stage) -deriving instance Show (PatSynRhs dom stage) -deriving instance Show (PatSynLhs dom stage) -deriving instance Show (PatSynWhere dom stage) -deriving instance Show (PatternTypeSignature dom stage) -deriving instance Show (Role dom stage) -deriving instance Show (Cmd dom stage) -deriving instance Show (LanguageExtension dom stage) -deriving instance Show (MatchLhs dom stage) +deriving instance Show (UQuasiQuote dom stage) +deriving instance Show (URhsGuard dom stage) +deriving instance Show (ULocalBind dom stage) +deriving instance Show (ULocalBinds dom stage) +deriving instance Show (UFixitySignature dom stage) +deriving instance Show (UTypeSignature dom stage) +deriving instance Show (UListCompBody dom stage) +deriving instance Show (UTupSecElem dom stage) +deriving instance Show (UTypeFamily dom stage) +deriving instance Show (UTypeFamilySpec dom stage) +deriving instance Show (UInjectivityAnn dom stage) +deriving instance Show (expr dom stage) => Show (UCaseRhs' expr dom stage) +deriving instance Show (expr dom stage) => Show (UGuardedCaseRhs' expr dom stage) +deriving instance Show (UPatternSynonym dom stage) +deriving instance Show (UPatSynRhs dom stage) +deriving instance Show (UPatSynLhs dom stage) +deriving instance Show (UPatSynWhere dom stage) +deriving instance Show (UPatternTypeSignature dom stage) +deriving instance Show (URole dom stage) +deriving instance Show (UCmd dom stage) +deriving instance Show (ULanguageExtension dom stage) +deriving instance Show (UMatchLhs dom stage) --- Literal -deriving instance Show (Literal dom stage) -deriving instance Show (k dom stage) => Show (Promoted k dom stage) +-- ULiteral +deriving instance Show (ULiteral dom stage) +deriving instance Show (k dom stage) => Show (UPromoted k dom stage) -- Base -deriving instance Show (Operator dom stage) -deriving instance Show (Name dom stage) -deriving instance Show (QualifiedName dom stage) -deriving instance Show (ModuleName dom stage) -deriving instance Show (UnqualName dom stage) -deriving instance Show (StringNode dom stage) -deriving instance Show (DataOrNewtypeKeyword dom stage) -deriving instance Show (DoKind dom stage) +deriving instance Show (UOperator dom stage) +deriving instance Show (UName dom stage) +deriving instance Show (UQualifiedName dom stage) +deriving instance Show (UModuleName dom stage) +deriving instance Show (UNamePart dom stage) +deriving instance Show (UStringNode dom stage) +deriving instance Show (UDataOrNewtypeKeyword dom stage) +deriving instance Show (UDoKind dom stage) deriving instance Show (TypeKeyword dom stage) -deriving instance Show (OverlapPragma dom stage) -deriving instance Show (CallConv dom stage) -deriving instance Show (ArrowAppl dom stage) -deriving instance Show (Safety dom stage) -deriving instance Show (ConlikeAnnot dom stage) +deriving instance Show (UOverlapPragma dom stage) +deriving instance Show (UCallConv dom stage) +deriving instance Show (UArrowAppl dom stage) +deriving instance Show (USafety dom stage) +deriving instance Show (UConlikeAnnot dom stage) deriving instance Show (Assoc dom stage) deriving instance Show (Precedence dom stage) deriving instance Show (LineNumber dom stage) -deriving instance Show (PhaseControl dom stage) +deriving instance Show (UPhaseControl dom stage) deriving instance Show (PhaseNumber dom stage) deriving instance Show (PhaseInvert dom stage) diff --git a/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs b/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs --- a/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs +++ b/Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs @@ -6,127 +6,127 @@ import Language.Haskell.Tools.AST.TH.SourceInfoTraversal import Control.Applicative -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.TH -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Stmts -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.TH +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Stmts +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.Ann -- Modules -deriveSourceInfoTraversal ''Module -deriveSourceInfoTraversal ''ModuleHead -deriveSourceInfoTraversal ''ExportSpecList -deriveSourceInfoTraversal ''ExportSpec -deriveSourceInfoTraversal ''IESpec -deriveSourceInfoTraversal ''SubSpec -deriveSourceInfoTraversal ''ModulePragma -deriveSourceInfoTraversal ''FilePragma -deriveSourceInfoTraversal ''ImportDecl -deriveSourceInfoTraversal ''ImportSpec -deriveSourceInfoTraversal ''ImportQualified -deriveSourceInfoTraversal ''ImportSource -deriveSourceInfoTraversal ''ImportSafe -deriveSourceInfoTraversal ''TypeNamespace -deriveSourceInfoTraversal ''ImportRenaming +deriveSourceInfoTraversal ''UModule +deriveSourceInfoTraversal ''UModuleHead +deriveSourceInfoTraversal ''UExportSpecs +deriveSourceInfoTraversal ''UExportSpec +deriveSourceInfoTraversal ''UIESpec +deriveSourceInfoTraversal ''USubSpec +deriveSourceInfoTraversal ''UModulePragma +deriveSourceInfoTraversal ''UFilePragma +deriveSourceInfoTraversal ''UImportDecl +deriveSourceInfoTraversal ''UImportSpec +deriveSourceInfoTraversal ''UImportQualified +deriveSourceInfoTraversal ''UImportSource +deriveSourceInfoTraversal ''UImportSafe +deriveSourceInfoTraversal ''UTypeNamespace +deriveSourceInfoTraversal ''UImportRenaming -- Declarations -deriveSourceInfoTraversal ''Decl -deriveSourceInfoTraversal ''ClassBody -deriveSourceInfoTraversal ''ClassElement -deriveSourceInfoTraversal ''DeclHead -deriveSourceInfoTraversal ''InstBody -deriveSourceInfoTraversal ''InstBodyDecl -deriveSourceInfoTraversal ''GadtConDecl -deriveSourceInfoTraversal ''GadtConType -deriveSourceInfoTraversal ''FieldWildcard -deriveSourceInfoTraversal ''FunDeps -deriveSourceInfoTraversal ''FunDep -deriveSourceInfoTraversal ''ConDecl -deriveSourceInfoTraversal ''FieldDecl -deriveSourceInfoTraversal ''Deriving -deriveSourceInfoTraversal ''InstanceRule -deriveSourceInfoTraversal ''InstanceHead -deriveSourceInfoTraversal ''TypeEqn -deriveSourceInfoTraversal ''KindConstraint -deriveSourceInfoTraversal ''TyVar -deriveSourceInfoTraversal ''Type -deriveSourceInfoTraversal ''Kind -deriveSourceInfoTraversal ''Context -deriveSourceInfoTraversal ''Assertion -deriveSourceInfoTraversal ''Expr -deriveSourceInfoTraversal ''CompStmt -deriveSourceInfoTraversal ''ValueBind -deriveSourceInfoTraversal ''Pattern -deriveSourceInfoTraversal ''PatternField -deriveSourceInfoTraversal ''Splice +deriveSourceInfoTraversal ''UDecl +deriveSourceInfoTraversal ''UClassBody +deriveSourceInfoTraversal ''UClassElement +deriveSourceInfoTraversal ''UDeclHead +deriveSourceInfoTraversal ''UInstBody +deriveSourceInfoTraversal ''UInstBodyDecl +deriveSourceInfoTraversal ''UGadtConDecl +deriveSourceInfoTraversal ''UGadtConType +deriveSourceInfoTraversal ''UFieldWildcard +deriveSourceInfoTraversal ''UFunDeps +deriveSourceInfoTraversal ''UFunDep +deriveSourceInfoTraversal ''UConDecl +deriveSourceInfoTraversal ''UFieldDecl +deriveSourceInfoTraversal ''UDeriving +deriveSourceInfoTraversal ''UInstanceRule +deriveSourceInfoTraversal ''UInstanceHead +deriveSourceInfoTraversal ''UTypeEqn +deriveSourceInfoTraversal ''UKindConstraint +deriveSourceInfoTraversal ''UTyVar +deriveSourceInfoTraversal ''UType +deriveSourceInfoTraversal ''UKind +deriveSourceInfoTraversal ''UContext +deriveSourceInfoTraversal ''UAssertion +deriveSourceInfoTraversal ''UExpr +deriveSourceInfoTraversal ''UCompStmt +deriveSourceInfoTraversal ''UValueBind +deriveSourceInfoTraversal ''UPattern +deriveSourceInfoTraversal ''UPatternField +deriveSourceInfoTraversal ''USplice deriveSourceInfoTraversal ''QQString -deriveSourceInfoTraversal ''Match -deriveSourceInfoTraversal ''Rhs -deriveSourceInfoTraversal ''GuardedRhs -deriveSourceInfoTraversal ''FieldUpdate -deriveSourceInfoTraversal ''Bracket -deriveSourceInfoTraversal ''TopLevelPragma -deriveSourceInfoTraversal ''Rule -deriveSourceInfoTraversal ''AnnotationSubject -deriveSourceInfoTraversal ''MinimalFormula -deriveSourceInfoTraversal ''ExprPragma -deriveSourceInfoTraversal ''SourceRange +deriveSourceInfoTraversal ''UMatch +deriveSourceInfoTraversal ''URhs +deriveSourceInfoTraversal ''UGuardedRhs +deriveSourceInfoTraversal ''UFieldUpdate +deriveSourceInfoTraversal ''UBracket +deriveSourceInfoTraversal ''UTopLevelPragma +deriveSourceInfoTraversal ''URule +deriveSourceInfoTraversal ''UAnnotationSubject +deriveSourceInfoTraversal ''UMinimalFormula +deriveSourceInfoTraversal ''UExprPragma +deriveSourceInfoTraversal ''USourceRange deriveSourceInfoTraversal ''Number -deriveSourceInfoTraversal ''QuasiQuote -deriveSourceInfoTraversal ''RhsGuard -deriveSourceInfoTraversal ''LocalBind -deriveSourceInfoTraversal ''LocalBinds -deriveSourceInfoTraversal ''FixitySignature -deriveSourceInfoTraversal ''TypeSignature -deriveSourceInfoTraversal ''ListCompBody -deriveSourceInfoTraversal ''TupSecElem -deriveSourceInfoTraversal ''TypeFamily -deriveSourceInfoTraversal ''TypeFamilySpec -deriveSourceInfoTraversal ''InjectivityAnn -deriveSourceInfoTraversal ''PatternSynonym -deriveSourceInfoTraversal ''PatSynRhs -deriveSourceInfoTraversal ''PatSynLhs -deriveSourceInfoTraversal ''PatSynWhere -deriveSourceInfoTraversal ''PatternTypeSignature -deriveSourceInfoTraversal ''Role -deriveSourceInfoTraversal ''Cmd -deriveSourceInfoTraversal ''LanguageExtension -deriveSourceInfoTraversal ''MatchLhs -deriveSourceInfoTraversal ''Stmt' -deriveSourceInfoTraversal ''Alt' -deriveSourceInfoTraversal ''CaseRhs' -deriveSourceInfoTraversal ''GuardedCaseRhs' +deriveSourceInfoTraversal ''UQuasiQuote +deriveSourceInfoTraversal ''URhsGuard +deriveSourceInfoTraversal ''ULocalBind +deriveSourceInfoTraversal ''ULocalBinds +deriveSourceInfoTraversal ''UFixitySignature +deriveSourceInfoTraversal ''UTypeSignature +deriveSourceInfoTraversal ''UListCompBody +deriveSourceInfoTraversal ''UTupSecElem +deriveSourceInfoTraversal ''UTypeFamily +deriveSourceInfoTraversal ''UTypeFamilySpec +deriveSourceInfoTraversal ''UInjectivityAnn +deriveSourceInfoTraversal ''UPatternSynonym +deriveSourceInfoTraversal ''UPatSynRhs +deriveSourceInfoTraversal ''UPatSynLhs +deriveSourceInfoTraversal ''UPatSynWhere +deriveSourceInfoTraversal ''UPatternTypeSignature +deriveSourceInfoTraversal ''URole +deriveSourceInfoTraversal ''UCmd +deriveSourceInfoTraversal ''ULanguageExtension +deriveSourceInfoTraversal ''UMatchLhs +deriveSourceInfoTraversal ''UStmt' +deriveSourceInfoTraversal ''UAlt' +deriveSourceInfoTraversal ''UCaseRhs' +deriveSourceInfoTraversal ''UGuardedCaseRhs' --- Literal -deriveSourceInfoTraversal ''Literal -deriveSourceInfoTraversal ''Promoted +-- ULiteral +deriveSourceInfoTraversal ''ULiteral +deriveSourceInfoTraversal ''UPromoted -- Base -deriveSourceInfoTraversal ''Operator -deriveSourceInfoTraversal ''Name -deriveSourceInfoTraversal ''QualifiedName -deriveSourceInfoTraversal ''ModuleName -deriveSourceInfoTraversal ''UnqualName -deriveSourceInfoTraversal ''StringNode -deriveSourceInfoTraversal ''DataOrNewtypeKeyword -deriveSourceInfoTraversal ''DoKind +deriveSourceInfoTraversal ''UOperator +deriveSourceInfoTraversal ''UName +deriveSourceInfoTraversal ''UQualifiedName +deriveSourceInfoTraversal ''UModuleName +deriveSourceInfoTraversal ''UNamePart +deriveSourceInfoTraversal ''UStringNode +deriveSourceInfoTraversal ''UDataOrNewtypeKeyword +deriveSourceInfoTraversal ''UDoKind deriveSourceInfoTraversal ''TypeKeyword -deriveSourceInfoTraversal ''OverlapPragma -deriveSourceInfoTraversal ''CallConv -deriveSourceInfoTraversal ''ArrowAppl -deriveSourceInfoTraversal ''Safety -deriveSourceInfoTraversal ''ConlikeAnnot +deriveSourceInfoTraversal ''UOverlapPragma +deriveSourceInfoTraversal ''UCallConv +deriveSourceInfoTraversal ''UArrowAppl +deriveSourceInfoTraversal ''USafety +deriveSourceInfoTraversal ''UConlikeAnnot deriveSourceInfoTraversal ''Assoc deriveSourceInfoTraversal ''Precedence deriveSourceInfoTraversal ''LineNumber -deriveSourceInfoTraversal ''PhaseControl +deriveSourceInfoTraversal ''UPhaseControl deriveSourceInfoTraversal ''PhaseNumber deriveSourceInfoTraversal ''PhaseInvert diff --git a/Language/Haskell/Tools/AST/Kinds.hs b/Language/Haskell/Tools/AST/Kinds.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Kinds.hs +++ /dev/null @@ -1,38 +0,0 @@ --- | Representation of Haskell Kinds -module Language.Haskell.Tools.AST.Kinds where - -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Base - --- | Kind constraint (@ :: * -> * @) -data KindConstraint dom stage - = KindConstraint { _kindConstr :: Ann Kind dom stage - } - --- | Haskell kinds -data Kind dom stage - = KindStar -- ^ @*@, the kind of types - | KindUnbox -- ^ @#@, the kind of unboxed types - | KindFn { _kindLeft :: Ann Kind dom stage - , _kindRight :: Ann Kind dom stage - } -- ^ @->@, the kind of type constructor - | KindParen { _kindParen :: Ann Kind dom stage - } -- ^ A parenthesised kind - | KindVar { _kindVar :: Ann Name dom stage - } -- ^ kind variable (using @PolyKinds@ extension) - | KindApp { _kindAppFun :: Ann Kind dom stage - , _kindAppArg :: Ann Kind dom stage - } -- ^ Kind application (@ k1 k2 @) - | KindList { _kindElem :: Ann Kind dom stage - } -- ^ A list kind (@ [k] @) - | KindPromoted { _kindPromoted :: Ann (Promoted Kind) dom stage - } -- ^ A promoted kind (@ '(k1,k2,k3) @) - -data Promoted t dom stage - = PromotedInt { _promotedIntValue :: Integer } - | PromotedString { _promotedStringValue :: String } - | PromotedCon { _promotedConName :: Ann Name dom stage } - | PromotedList { _promotedElements :: AnnList t dom stage } - | PromotedTuple { _promotedElements :: AnnList t dom stage } - | PromotedUnit diff --git a/Language/Haskell/Tools/AST/Literals.hs b/Language/Haskell/Tools/AST/Literals.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Literals.hs +++ /dev/null @@ -1,29 +0,0 @@ --- | Representation of Haskell literals -module Language.Haskell.Tools.AST.Literals where - -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Base - --- | Haskell literals -data Literal dom stage - = CharLit { _charLitValue :: Char - } -- ^ Character literal: @'c'@ - | StringLit { _stringLitValue :: String - } -- ^ String literal: @"abc"@ - | IntLit { _intLitValue :: Integer - } -- ^ Integer literal: @12@ - | FracLit { _fracLitValue :: Rational - } -- ^ Fractional literal: @3.14@ - | PrimIntLit { _intLitValue :: Integer - } -- ^ Primitive integer literal (of type @Int#@): @32#@ - | PrimWordLit { _intLitValue :: Integer - } -- ^ Primitive word literal (of type @Word#@): @32##@ - | PrimFloatLit { _floatLitValue :: Rational - } -- ^ Primitive float literal (of type @Float#@): @3.14#@ - | PrimDoubleLit { _floatLitValue :: Rational - } -- ^ Primitive double literal (of type @Double#@): @3.14##@ - | PrimCharLit { _charLitValue :: Char - } -- ^ Primitive character literal (of type @Char#@): @'c'#@ - | PrimStringLit { _stringLitValue :: String - } -- ^ Prmitive string literal (of type @Addr#@): @"xxx"#@ - diff --git a/Language/Haskell/Tools/AST/MakeASTReferences.hs b/Language/Haskell/Tools/AST/MakeASTReferences.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/MakeASTReferences.hs @@ -0,0 +1,27 @@ +{-# LANGUAGE LambdaCase, TemplateHaskellQuotes #-} +-- | Contains a transformation to alter the references generated by the template haskell +-- function @makeReferences@. +module Language.Haskell.Tools.AST.MakeASTReferences where + +import Control.Monad +import Control.Reference ((&)) +import Language.Haskell.Tools.AST.Ann (Ann, element) +import Language.Haskell.TH + +import Debug.Trace + +-- | Change the generated references to have the context of an annotated element. +-- Modifies the types according to the changes. This trasformation makes all +-- generated references monomorphic. +toASTReferences :: Q [Dec] -> Q [Dec] +toASTReferences = fmap (map $ \case + SigD name (ForallT vars ctx (refType `AppT` (ctxOrig `AppT` dom `AppT` stage) + `AppT` _ + `AppT` fldOrig + `AppT` _)) + -> SigD name (ForallT vars ctx (refType `AppT` (ConT ''Ann `AppT` ctxOrig `AppT` dom `AppT` stage) + `AppT` (ConT ''Ann `AppT` ctxOrig `AppT` dom `AppT` stage) + `AppT` fldOrig + `AppT` fldOrig)) + ValD pat (NormalB e) locs -> ValD pat (NormalB (InfixE (Just (VarE 'element)) (VarE '(&)) (Just e))) locs + d -> d) diff --git a/Language/Haskell/Tools/AST/Modules.hs b/Language/Haskell/Tools/AST/Modules.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Modules.hs +++ /dev/null @@ -1,96 +0,0 @@ --- | Representation of Haskell modules, imports and exports. Also contains file-level pragmas. -module Language.Haskell.Tools.AST.Modules where - -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Decls - --- | The representation of a haskell module, that is a separate compilation unit. --- It may or may not have a header. -data Module dom stage - = Module { _filePragmas :: AnnList FilePragma dom stage - , _modHead :: AnnMaybe ModuleHead dom stage - , _modImports :: AnnList ImportDecl dom stage - , _modDecl :: AnnList Decl dom stage - } - --- | Module declaration with name and (optional) exports -data ModuleHead dom stage - = ModuleHead { _mhName :: Ann ModuleName dom stage - , _mhExports :: AnnMaybe ExportSpecList dom stage - , _mhPragma :: AnnMaybe ModulePragma dom stage - } - --- | A list of export specifications surrounded by parentheses -data ExportSpecList dom stage - = ExportSpecList { _espExports :: AnnList ExportSpec dom stage } - --- | Export specifier -data ExportSpec dom stage - = DeclExport { _exportDecl :: Ann IESpec dom stage - } -- ^ Export a name and related names - | ModuleExport { _exportModuleName :: Ann ModuleName dom stage - } -- ^ The export of an imported module (@ module A @) - --- | Marks a name to be imported or exported with related names (subspecifier) -data IESpec dom stage - = IESpec { _ieName :: Ann Name dom stage - , _ieSubspec :: AnnMaybe SubSpec dom stage - } - --- | Marks how related names will be imported or exported with a given name -data SubSpec dom stage - = SubSpecAll -- @(..)@: a class exported with all of its methods, or a datatype exported with all of its constructors. - | SubSpecList { _essList :: AnnList Name dom stage } -- @(a,b,c)@: a class exported with some of its methods, or a datatype exported with some of its constructors. - --- | Pragmas that must be used before defining the module -data FilePragma dom stage - = LanguagePragma { _lpPragmas :: AnnList LanguageExtension dom stage - } -- ^ LANGUAGE pragmdom stage - | OptionsPragma { _opStr :: Ann StringNode dom stage - } -- ^ OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC - --- | Pragmas that must be used after the module head -data ModulePragma dom stage - = ModuleWarningPragma { _modWarningStr :: AnnList StringNode dom stage - } -- ^ a warning pragma attached to the module - | ModuleDeprecatedPragma { _modDeprecatedPragma :: AnnList StringNode dom stage - } -- ^ a deprecated pragma attached to the module - --- | The name of the enabled language extension, for example (@ LambdaCase @) -data LanguageExtension dom stage = LanguageExtension { _langExt :: String } - --- | An import declaration: @import Module.Name@ -data ImportDecl dom stage - = ImportDecl { _importSource :: AnnMaybe ImportSource dom stage - , _importQualified :: AnnMaybe ImportQualified dom stage - , _importSafe :: AnnMaybe ImportSafe dom stage - , _importPkg :: AnnMaybe StringNode dom stage - , _importModule :: Ann ModuleName dom stage - , _importAs :: AnnMaybe ImportRenaming dom stage - , _importSpec :: AnnMaybe ImportSpec dom stage - } - --- | Restriction on the imported names -data ImportSpec dom stage - = ImportSpecList { _importSpecList :: AnnList IESpec dom stage - } -- ^ Restrict the import definition to ONLY import the listed names - | ImportSpecHiding { _importSpecHiding :: AnnList IESpec dom stage - } -- ^ Restrict the import definition to DONT import the listed names - --- | Marks the import as qualified: @qualified@ -data ImportQualified dom stage = ImportQualified - --- | Marks the import as source: @{-# SOURCE #-}@ -data ImportSource dom stage = ImportSource - --- | Marks the import as safe: @safe@ -data ImportSafe dom stage = ImportSafe - --- | Marks an imported name to belong to the type namespace: @type@ -data TypeNamespace dom stage = TypeNamespace - --- | Renaming imports (@ as A @) -data ImportRenaming dom stage = ImportRenaming { _importRename :: Ann ModuleName dom stage } diff --git a/Language/Haskell/Tools/AST/Modules.hs-boot b/Language/Haskell/Tools/AST/Modules.hs-boot deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Modules.hs-boot +++ /dev/null @@ -1,8 +0,0 @@ -{-# LANGUAGE RoleAnnotations #-} -module Language.Haskell.Tools.AST.Modules where - -type role Module nominal nominal -data Module dom stage - -type role ImportDecl nominal nominal -data ImportDecl dom stage diff --git a/Language/Haskell/Tools/AST/Patterns.hs b/Language/Haskell/Tools/AST/Patterns.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Patterns.hs +++ /dev/null @@ -1,70 +0,0 @@ --- | Representation of Haskell patterns -module Language.Haskell.Tools.AST.Patterns where - -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Types -import {-# SOURCE #-} Language.Haskell.Tools.AST.Exprs (Expr, FieldWildcard) -import {-# SOURCE #-} Language.Haskell.Tools.AST.TH - - --- | Representation of patterns for pattern bindings -data Pattern dom stage - = VarPat { _patternName :: Ann Name dom stage - } -- ^ Pattern name binding - | LitPat { _patternLiteral :: Ann Literal dom stage - } -- ^ Literal pattern - | InfixPat { _patternLhs :: Ann Pattern dom stage - , _patternOperator :: Ann Operator dom stage - , _patternRhs :: Ann Pattern dom stage - } -- ^ Infix constructor application pattern (@ a :+: b @) - | AppPat { _patternName :: Ann Name dom stage - , _patternArgs :: AnnList Pattern dom stage - } -- ^ Constructor application pattern (@ Point x y @) - | TuplePat { _patternElems :: AnnList Pattern dom stage - } -- ^ Tuple pattern (@ (x,y) @) - | UnboxTuplePat { _patternElems :: AnnList Pattern dom stage - } -- ^ Unboxed tuple pattern (@ (# x, y #) @) - | ListPat { _patternElems :: AnnList Pattern dom stage - } -- ^ List pattern (@ [1,2,a,x] @) - | ParArrPat { _patternElems :: AnnList Pattern dom stage - } -- ^ Parallel array pattern (@ [:1,2,a,x:] @) - | ParenPat { _patternInner :: Ann Pattern dom stage - } -- ^ Parenthesised patterns - | RecPat { _patternName :: Ann Name dom stage - , _patternFields :: AnnList PatternField dom stage - } -- ^ Record pattern (@ Point { x = 3, y } @) - | AsPat { _patternName :: Ann Name dom stage - , _patternInner :: Ann Pattern dom stage - } -- ^ As-pattern (explicit name binding) (@ ls\@(hd:_) @) - | WildPat -- ^ Wildcard pattern: (@ _ @) - | IrrPat { _patternInner :: Ann Pattern dom stage - } -- ^ Irrefutable pattern (@ ~(x:_) @) - | BangPat { _patternInner :: Ann Pattern dom stage - } -- ^ Bang pattern (@ !x @) - | TypeSigPat { _patternInner :: Ann Pattern dom stage - , _patternType :: Ann Type dom stage - } -- ^ Pattern with explicit type signature (@ __ :: Int @) - | ViewPat { _patternExpr :: Ann Expr dom stage - , _patternInner :: Ann Pattern dom stage - } -- ^ View pattern (@ f -> Just 1 @) - -- regular list pattern omitted - -- xml patterns omitted - | SplicePat { _patternSplice :: Ann Splice dom stage - } -- ^ Splice patterns: @$(generateX inp)@ - | QuasiQuotePat { _patQQ :: Ann QuasiQuote dom stage - } -- ^ Quasi-quoted patterns: @[| 1 + 2 |]@ - | NPlusKPat { _patternName :: Ann Name dom stage - , _patternLit :: Ann Literal dom stage - } - --- Field specification of a record pattern -data PatternField dom stage - = NormalFieldPattern { _fieldPatternName :: Ann Name dom stage - , _fieldPattern :: Ann Pattern dom stage - } -- ^ Named field pattern (@ p = Point 3 2 @) - | FieldPunPattern { _fieldPatternName :: Ann Name dom stage - } -- ^ Named field pun (@ p @) - | FieldWildcardPattern { _fieldPatternWildcard :: Ann FieldWildcard dom stage - } -- ^ Wildcard field pattern (@ .. @) diff --git a/Language/Haskell/Tools/AST/References.hs b/Language/Haskell/Tools/AST/References.hs --- a/Language/Haskell/Tools/AST/References.hs +++ b/Language/Haskell/Tools/AST/References.hs @@ -1,124 +1,141 @@ {-# LANGUAGE FlexibleContexts, TemplateHaskell #-} --- Generated references for handling the custom AST +-- | Generated references for AST elements. module Language.Haskell.Tools.AST.References where -import Control.Reference +import Control.Reference hiding (element) +import Language.Haskell.Tools.AST.MakeASTReferences -import Language.Haskell.Tools.AST.Modules -import Language.Haskell.Tools.AST.TH -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Stmts -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Kinds -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base +import Language.Haskell.Tools.AST.Representation.Modules +import Language.Haskell.Tools.AST.Representation.TH +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Stmts +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names import Language.Haskell.Tools.AST.Ann --- Modules -makeReferences ''Module -makeReferences ''ModuleHead -makeReferences ''ExportSpecList -makeReferences ''ExportSpec -makeReferences ''IESpec -makeReferences ''SubSpec -makeReferences ''ModulePragma -makeReferences ''ImportDecl -makeReferences ''ImportSpec -makeReferences ''ImportQualified -makeReferences ''ImportSource -makeReferences ''ImportSafe -makeReferences ''TypeNamespace -makeReferences ''ImportRenaming +-- * Modules +$(toASTReferences (makeReferences ''UModule)) +$(toASTReferences (makeReferences ''UModuleHead)) +$(toASTReferences (makeReferences ''UExportSpecs)) +$(toASTReferences (makeReferences ''UExportSpec)) +$(toASTReferences (makeReferences ''UIESpec)) +$(toASTReferences (makeReferences ''USubSpec)) +$(toASTReferences (makeReferences ''UModulePragma)) +$(toASTReferences (makeReferences ''UImportDecl)) +$(toASTReferences (makeReferences ''UImportSpec)) +$(toASTReferences (makeReferences ''UImportQualified)) +$(toASTReferences (makeReferences ''UImportSource)) +$(toASTReferences (makeReferences ''UImportSafe)) +$(toASTReferences (makeReferences ''UTypeNamespace)) +$(toASTReferences (makeReferences ''UImportRenaming)) +$(toASTReferences (makeReferences ''UModuleName)) +$(toASTReferences (makeReferences ''ULanguageExtension)) +$(toASTReferences (makeReferences ''TypeKeyword)) --- Declarations -makeReferences ''Decl -makeReferences ''ClassBody -makeReferences ''ClassElement -makeReferences ''DeclHead -makeReferences ''InstBody -makeReferences ''InstBodyDecl -makeReferences ''GadtConDecl -makeReferences ''GadtConType -makeReferences ''FunDeps -makeReferences ''FunDep -makeReferences ''ConDecl -makeReferences ''FieldDecl -makeReferences ''Deriving -makeReferences ''InstanceRule -makeReferences ''InstanceHead -makeReferences ''TypeEqn -makeReferences ''KindConstraint -makeReferences ''TyVar -makeReferences ''Type -makeReferences ''Kind -makeReferences ''Context -makeReferences ''Assertion -makeReferences ''Expr -makeReferences ''Stmt' -makeReferences ''CompStmt -makeReferences ''ValueBind -makeReferences ''Pattern -makeReferences ''PatternField -makeReferences ''Splice -makeReferences ''QQString -makeReferences ''Match -makeReferences ''Alt' -makeReferences ''Rhs -makeReferences ''GuardedRhs -makeReferences ''FieldUpdate -makeReferences ''Bracket -makeReferences ''TopLevelPragma -makeReferences ''Rule -makeReferences ''AnnotationSubject -makeReferences ''MinimalFormula -makeReferences ''ExprPragma -makeReferences ''SourceRange -makeReferences ''Number -makeReferences ''QuasiQuote -makeReferences ''RhsGuard -makeReferences ''LocalBind -makeReferences ''LocalBinds -makeReferences ''FixitySignature -makeReferences ''TypeSignature -makeReferences ''ListCompBody -makeReferences ''TupSecElem -makeReferences ''TypeFamily -makeReferences ''TypeFamilySpec -makeReferences ''InjectivityAnn -makeReferences ''CaseRhs' -makeReferences ''GuardedCaseRhs' -makeReferences ''PatternSynonym -makeReferences ''PatSynRhs -makeReferences ''PatSynLhs -makeReferences ''PatSynWhere -makeReferences ''PatternTypeSignature -makeReferences ''Role -makeReferences ''LanguageExtension -makeReferences ''MatchLhs +-- * Declarations +$(toASTReferences (makeReferences ''UDecl)) +$(toASTReferences (makeReferences ''UClassBody)) +$(toASTReferences (makeReferences ''UClassElement)) +$(toASTReferences (makeReferences ''UDeclHead)) +$(toASTReferences (makeReferences ''UInstBody)) +$(toASTReferences (makeReferences ''UInstBodyDecl)) +$(toASTReferences (makeReferences ''UTypeFamily)) +$(toASTReferences (makeReferences ''UTypeFamilySpec)) +$(toASTReferences (makeReferences ''UInjectivityAnn)) +$(toASTReferences (makeReferences ''UDataOrNewtypeKeyword)) +$(toASTReferences (makeReferences ''UGadtConDecl)) +$(toASTReferences (makeReferences ''UGadtConType)) +$(toASTReferences (makeReferences ''UPatternSynonym)) +$(toASTReferences (makeReferences ''UPatSynRhs)) +$(toASTReferences (makeReferences ''UPatSynLhs)) +$(toASTReferences (makeReferences ''UPatSynWhere)) +$(toASTReferences (makeReferences ''UPatternTypeSignature)) +$(toASTReferences (makeReferences ''URole)) +$(toASTReferences (makeReferences ''UFunDeps)) +$(toASTReferences (makeReferences ''UFunDep)) +$(toASTReferences (makeReferences ''UConDecl)) +$(toASTReferences (makeReferences ''UFieldDecl)) +$(toASTReferences (makeReferences ''UDeriving)) +$(toASTReferences (makeReferences ''UInstanceRule)) +$(toASTReferences (makeReferences ''UInstanceHead)) +$(toASTReferences (makeReferences ''UTypeEqn)) +$(toASTReferences (makeReferences ''URule)) +$(toASTReferences (makeReferences ''UOverlapPragma)) +$(toASTReferences (makeReferences ''UCallConv)) +$(toASTReferences (makeReferences ''USafety)) +$(toASTReferences (makeReferences ''UPhaseControl)) +$(toASTReferences (makeReferences ''PhaseNumber)) +$(toASTReferences (makeReferences ''PhaseInvert)) +$(toASTReferences (makeReferences ''UTopLevelPragma)) +$(toASTReferences (makeReferences ''UAnnotationSubject)) +$(toASTReferences (makeReferences ''UMinimalFormula)) +$(toASTReferences (makeReferences ''USourceRange)) +$(toASTReferences (makeReferences ''Number)) --- Literal -makeReferences ''Literal -makeReferences ''Promoted --- Base -makeReferences ''Operator -makeReferences ''Name -makeReferences ''QualifiedName -makeReferences ''ModuleName -makeReferences ''UnqualName -makeReferences ''StringNode -makeReferences ''DataOrNewtypeKeyword -makeReferences ''DoKind -makeReferences ''TypeKeyword -makeReferences ''OverlapPragma -makeReferences ''CallConv -makeReferences ''ArrowAppl -makeReferences ''Safety -makeReferences ''Assoc -makeReferences ''Precedence -makeReferences ''PhaseControl -makeReferences ''PhaseNumber -makeReferences ''PhaseInvert +-- * Binds +$(toASTReferences (makeReferences ''UMatch)) +$(toASTReferences (makeReferences ''URhs)) +$(toASTReferences (makeReferences ''UGuardedRhs)) +$(toASTReferences (makeReferences ''URhsGuard)) +$(toASTReferences (makeReferences ''ULocalBind)) +$(toASTReferences (makeReferences ''ULocalBinds)) +$(toASTReferences (makeReferences ''UFixitySignature)) +$(toASTReferences (makeReferences ''Assoc)) +$(toASTReferences (makeReferences ''Precedence)) +$(toASTReferences (makeReferences ''UTypeSignature)) +$(toASTReferences (makeReferences ''UMatchLhs)) + +-- * Kinds +$(toASTReferences (makeReferences ''UKindConstraint)) + +-- * Types +$(toASTReferences (makeReferences ''UValueBind)) +$(toASTReferences (makeReferences ''UTyVar)) +$(toASTReferences (makeReferences ''UType)) +$(toASTReferences (makeReferences ''UKind)) +$(toASTReferences (makeReferences ''UContext)) +$(toASTReferences (makeReferences ''UAssertion)) + +-- * Expressions +$(toASTReferences (makeReferences ''UExpr)) +$(toASTReferences (makeReferences ''UAlt')) +$(toASTReferences (makeReferences ''UFieldUpdate)) +$(toASTReferences (makeReferences ''UTupSecElem)) +$(toASTReferences (makeReferences ''UExprPragma)) +$(toASTReferences (makeReferences ''UCaseRhs')) +$(toASTReferences (makeReferences ''UGuardedCaseRhs')) +$(toASTReferences (makeReferences ''UArrowAppl)) + +-- * Statements +$(toASTReferences (makeReferences ''UStmt')) +$(toASTReferences (makeReferences ''UCompStmt)) +$(toASTReferences (makeReferences ''UListCompBody)) +$(toASTReferences (makeReferences ''UDoKind)) + +-- * Patterns +$(toASTReferences (makeReferences ''UPattern)) +$(toASTReferences (makeReferences ''UPatternField)) + +-- * Template Haskell +$(toASTReferences (makeReferences ''USplice)) +$(toASTReferences (makeReferences ''UQuasiQuote)) +$(toASTReferences (makeReferences ''QQString)) +$(toASTReferences (makeReferences ''UBracket)) + +-- * Literals +$(toASTReferences (makeReferences ''ULiteral)) +$(toASTReferences (makeReferences ''UPromoted)) + +-- * Names +$(toASTReferences (makeReferences ''UOperator)) +$(toASTReferences (makeReferences ''UName)) +$(toASTReferences (makeReferences ''UQualifiedName)) +$(toASTReferences (makeReferences ''UNamePart)) +$(toASTReferences (makeReferences ''UStringNode)) + diff --git a/Language/Haskell/Tools/AST/Representation/Binds.hs b/Language/Haskell/Tools/AST/Representation/Binds.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Binds.hs @@ -0,0 +1,101 @@ +-- | Representation of Haskell AST value and function bindings (both local and top-level) +module Language.Haskell.Tools.AST.Representation.Binds where + +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Literals +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH + +-- | Value binding for top-level and local bindings +data UValueBind dom stage + = USimpleBind { _valBindPat :: Ann UPattern dom stage + , _valBindRhs :: Ann URhs dom stage + , _valBindLocals :: AnnMaybeG ULocalBinds dom stage + } -- ^ Non-function binding (@ v = "12" @) + -- TODO: use one name for a function instead of names in each match + | UFunBind { _funBindMatches :: AnnListG UMatch dom stage + } -- ^ Function binding (@ f 0 = 1; f x = x @). All matches must have the same name. + +-- | Clause of function binding +data UMatch dom stage + = UMatch { _matchLhs :: Ann UMatchLhs dom stage + , _matchRhs :: Ann URhs dom stage + , _matchBinds :: AnnMaybeG ULocalBinds dom stage + } + +-- | Something on the left side of the match +data UMatchLhs dom stage + = UNormalLhs { _matchLhsName :: Ann UName dom stage + , _matchLhsArgs :: AnnListG UPattern dom stage + } -- ^ A match lhs with the function name and parameter names (@ f a b @) + | UInfixLhs { _matchLhsLhs :: Ann UPattern dom stage + , _matchLhsOperator :: Ann UOperator dom stage + , _matchLhsRhs :: Ann UPattern dom stage + , _matchLhsArgs :: AnnListG UPattern dom stage + } -- ^ An infix match lhs for an operator (@ a + b @) + +-- | Local bindings attached to a declaration (@ where x = 42 @) +data ULocalBinds dom stage + = ULocalBinds { _localBinds :: AnnListG ULocalBind dom stage + } + +-- | Bindings that are enabled in local blocks (where or let). +data ULocalBind dom stage + -- TODO: check that no other signature can be inside a local binding + = ULocalValBind { _localVal :: Ann UValueBind dom stage + } -- ^ A local binding for a value + | ULocalSignature { _localSig :: Ann UTypeSignature dom stage + } -- ^ A local type signature + | ULocalFixity { _localFixity :: Ann UFixitySignature dom stage + } -- ^ A local fixity declaration + +-- | A type signature (@ f :: Int -> Int @) +data UTypeSignature dom stage + = UTypeSignature { _tsName :: AnnListG UName dom stage + , _tsType :: Ann UType dom stage + } + +-- * Fixities + +-- | A fixity signature (@ infixl 5 +, - @). +data UFixitySignature dom stage + = UFixitySignature { _fixityAssoc :: Ann Assoc dom stage + , _fixityPrecedence :: Ann Precedence dom stage + , _fixityOperators :: AnnListG UOperator dom stage + } + +-- | Associativity of an operator. +data Assoc dom stage + = AssocNone -- ^ non-associative operator (declared with @infix@) + | AssocLeft -- ^ left-associative operator (declared with @infixl@) + | AssocRight -- ^ right-associative operator (declared with @infixr@) + +-- | Numeric precedence of an operator +data Precedence dom stage + = Precedence { _precedenceValue :: Int } + +-- | Right hand side of a value binding (possible with guards): (@ = 3 @ or @ | x == 1 = 3; | otherwise = 4 @) +data URhs dom stage + = UUnguardedRhs { _rhsExpr :: Ann UExpr dom stage + } -- ^ An unguarded right-hand-side (@ = 3 @) + | UGuardedRhss { _rhsGuards :: AnnListG UGuardedRhs dom stage + } -- ^ An unguarded right-hand-side (@ | x == 1 = 3; | otherwise = 4 @) + +-- | A guarded right-hand side of a value binding (@ | x > 3 = 2 @) +data UGuardedRhs dom stage + = UGuardedRhs { _guardStmts :: AnnListG URhsGuard dom stage -- ^ Cannot be empty. + , _guardExpr :: Ann UExpr dom stage + } + +-- | Guards for value bindings and pattern matches (@ Just v <- x, v > 1 @) +data URhsGuard dom stage + = UGuardBind { _guardPat :: Ann UPattern dom stage + , _guardRhs :: Ann UExpr dom stage + } -- ^ A bind statement in a pattern guard (@ Just v <- x @) + | UGuardLet { _guardBinds :: AnnListG ULocalBind dom stage + } -- ^ A let statement in a pattern guard (@ let x = 3 @) + | UGuardCheck { _guardCheck :: Ann UExpr dom stage + } -- ^ An expression to check for a pattern guard diff --git a/Language/Haskell/Tools/AST/Representation/Binds.hs-boot b/Language/Haskell/Tools/AST/Representation/Binds.hs-boot new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Binds.hs-boot @@ -0,0 +1,11 @@ +{-# LANGUAGE RoleAnnotations #-} +module Language.Haskell.Tools.AST.Representation.Binds where + +type role ULocalBind nominal nominal +data ULocalBind dom stage + +type role ULocalBinds nominal nominal +data ULocalBinds dom stage + +type role URhsGuard nominal nominal +data URhsGuard dom stage diff --git a/Language/Haskell/Tools/AST/Representation/Decls.hs b/Language/Haskell/Tools/AST/Representation/Decls.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Decls.hs @@ -0,0 +1,434 @@ +-- | Representation of Haskell AST definitions. These include definition of data types, classes, instances and so on. +-- The definition of value bindings are in the Binds module. +module Language.Haskell.Tools.AST.Representation.Decls where + +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Kinds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Ann +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH + +-- * Declarations + +-- | Haskell declaration +data UDecl dom stage + = UTypeDecl { _declHead :: Ann UDeclHead dom stage + , _declType :: Ann UType dom stage + } -- ^ A type synonym ( @type String = [Char]@ ) + | UTypeFamilyDecl { _declTypeFamily :: Ann UTypeFamily dom stage + } -- ^ A type family declaration ( @type family F x@ ) + | UClosedTypeFamilyDecl { _declHead :: Ann UDeclHead dom stage + , _declKind :: AnnMaybeG UKindConstraint dom stage + , _declDecl :: AnnListG UTypeEqn dom stage -- ^ cannot be empty + } -- ^ A closed type family declaration + | UDataDecl { _declNewtype :: Ann UDataOrNewtypeKeyword dom stage + , _declCtx :: AnnMaybeG UContext dom stage + , _declHead :: Ann UDeclHead dom stage + , _declCons :: AnnListG UConDecl dom stage + , _declDeriving :: AnnMaybeG UDeriving dom stage + } -- ^ A data or newtype declaration. Empty data type declarations without + -- where keyword are always belong to DataDecl. + | UGDataDecl { _declNewtype :: Ann UDataOrNewtypeKeyword dom stage + , _declCtx :: AnnMaybeG UContext dom stage + , _declHead :: Ann UDeclHead dom stage + , _declKind :: AnnMaybeG UKindConstraint dom stage + , _declGadt :: AnnListG UGadtConDecl dom stage + , _declDeriving :: AnnMaybeG UDeriving dom stage + } -- ^ A GADT-style data or newtype declaration. + | UTypeInstDecl { _declInstance :: Ann UInstanceRule dom stage + , _declAssignedType :: Ann UType dom stage + } -- ^ Type family instance declaration (@ type instance Fam T = AssignedT @) + | UDataInstDecl { _declNewtype :: Ann UDataOrNewtypeKeyword dom stage + , _declInstance :: Ann UInstanceRule dom stage + , _declCons :: AnnListG UConDecl dom stage + , _declDeriving :: AnnMaybeG UDeriving dom stage + } -- ^ Data instance declaration (@ data instance Fam T = Con1 | Con2 @) + | UGDataInstDecl { _declNewtype :: Ann UDataOrNewtypeKeyword dom stage + , _declInstance :: Ann UInstanceRule dom stage + , _declKind :: AnnMaybeG UKindConstraint dom stage + , _declGadt :: AnnListG UGadtConDecl dom stage + } -- ^ GADT-style data instance declaration (@ data instance Fam T where ... @) + | UClassDecl { _declCtx :: AnnMaybeG UContext dom stage + , _declHead :: Ann UDeclHead dom stage + , _declFunDeps :: AnnMaybeG UFunDeps dom stage + , _declBody :: AnnMaybeG UClassBody dom stage + } -- ^ Type class declaration (@ class X a [where f = ...] @) + | UInstDecl { _declOverlap :: AnnMaybeG UOverlapPragma dom stage + , _declInstRule :: Ann UInstanceRule dom stage + , _declInstDecl :: AnnMaybeG UInstBody dom stage + } -- ^ Instance declaration (@ instance X T [where f = ...] @) + | UPatternSynonymDecl { _declPatSyn :: Ann UPatternSynonym dom stage + } -- ^ Pattern synonyms (@ pattern Arrow t1 t2 = App "->" [t1, t2] @) + | UDerivDecl { _declOverlap :: AnnMaybeG UOverlapPragma dom stage + , _declInstRule :: Ann UInstanceRule dom stage + } -- ^ Standalone deriving declaration (@ deriving instance X T @) + | UFixityDecl { _declFixity :: Ann UFixitySignature dom stage + } -- ^ Fixity declaration (@ infixl 5 +, - @) + | UDefaultDecl { _declTypes :: AnnListG UType dom stage + } -- ^ Default types (@ default (T1, T2) @) + | UTypeSigDecl { _declTypeSig :: Ann UTypeSignature dom stage + } -- ^ Type signature declaration (@ f :: Int -> Int @) + | UPatTypeSigDecl { _declPatTypeSig :: Ann UPatternTypeSignature dom stage + } -- ^ Pattern type signature declaration (@ pattern Succ :: Int -> Int @) + | UValueBinding { _declValBind :: Ann UValueBind dom stage + } -- ^ Function or value binding (@ f x = 12 @) + | UForeignImport { _declCallConv :: Ann UCallConv dom stage + , _declSafety :: AnnMaybeG USafety dom stage + , _declName :: Ann UName dom stage + , _declType :: Ann UType dom stage + } -- ^ Foreign import (@ foreign import _foo :: Int -> IO Int @) + | UForeignExport { _declCallConv :: Ann UCallConv dom stage + , _declName :: Ann UName dom stage + , _declType :: Ann UType dom stage + } -- ^ Foreign export (@ foreign export ccall _foo :: Int -> IO Int @) + | UPragmaDecl { _declPragma :: Ann UTopLevelPragma dom stage + } -- ^ Top-level pragmas + | URoleDecl { _declRoleType :: Ann UQualifiedName dom stage + , _declRoles :: AnnListG URole dom stage + } -- ^ Role annotations (@ type role Ptr representational @) + | USpliceDecl { _declSplice :: Ann USplice dom stage + } -- ^ A Template Haskell splice declaration (@ $(generateDecls) @) + +-- The declared (possibly parameterized) type (@ A x :+: B y @). +data UDeclHead dom stage + = UDeclHead { _dhName :: Ann UName dom stage + } -- ^ Type or class name + | UDHParen { _dhBody :: Ann UDeclHead dom stage + } -- ^ Parenthesized type + | UDHApp { _dhAppFun :: Ann UDeclHead dom stage + , _dhAppOperand :: Ann UTyVar dom stage + } -- ^ Type application + | UDHInfix { _dhLeft :: Ann UTyVar dom stage + , _dhOperator :: Ann UOperator dom stage + , _dhRight :: Ann UTyVar dom stage + } -- ^ Infix application of the type/class name to the left operand + +-- * Type class definitions + +-- | The list of declarations that can appear in a typeclass +data UClassBody dom stage + = UClassBody { _cbElements :: AnnListG UClassElement dom stage + } + +-- | Members of a class declaration +data UClassElement dom stage + = UClsSig { _ceTypeSig :: Ann UTypeSignature dom stage + } -- ^ Signature: @ f :: A -> B @ + | UClsDef { _ceBind :: Ann UValueBind dom stage + } -- ^ Default binding: @ f x = "aaa" @ + | UClsTypeFam { _ceTypeFam :: Ann UTypeFamily dom stage + } -- ^ Declaration of an associated type synonym: @ type T x :: * @ + | UClsTypeDef { _ceHead :: Ann UDeclHead dom stage + , _ceKind :: Ann UType dom stage + } -- ^ Default choice for type synonym: @ type T x = TE @ or @ type instance T x = TE @ + | UClsDefSig { _ceName :: Ann UName dom stage + , _ceType :: Ann UType dom stage + } -- ^ Default signature (by using @DefaultSignatures@): @ default _enum :: (Generic a, GEnum (Rep a)) => [a] @ + | UClsMinimal { _pragmaFormula :: Ann UMinimalFormula dom stage + } -- ^ Minimal pragma: @ {-# MINIMAL (==) | (/=) #-} @ + -- not supported yet (GHC 8.0.1) + -- | UClsPatSig { _cePatSig :: Ann UPatternTypeSignature dom stage + -- } -- ^ Pattern signature in a class declaration (by using @PatternSynonyms@) + +-- * Type class instances + +-- | The instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword. +data UInstanceRule dom stage + = UInstanceRule { _irVars :: AnnMaybeG (AnnListG UTyVar) dom stage + , _irCtx :: AnnMaybeG UContext dom stage + , _irHead :: Ann UInstanceHead dom stage + } -- ^ Instance head as an instance rule (@ X a => Y a @) + +-- | The specification of the class instance declaration +data UInstanceHead dom stage + = UInstanceHeadCon { _ihConName :: Ann UName dom stage + } -- ^ Type or class name + | UInstanceHeadInfix { _ihLeftOp :: Ann UType dom stage + , _ihOperator :: Ann UName dom stage + } -- ^ Infix application of the type/class name to the left operand + | UInstanceHeadParen { _ihHead :: Ann UInstanceHead dom stage + } -- ^ Parenthesized instance head + | UInstanceHeadApp { _ihFun :: Ann UInstanceHead dom stage + , _ihType :: Ann UType dom stage + } -- ^ Application to one more type + +-- | Instance body is the implementation of the class functions (@ where a x = 1; b x = 2 @) +data UInstBody dom stage + = UInstBody { _instBodyDecls :: AnnListG UInstBodyDecl dom stage + } + +-- | Declarations inside an instance declaration. +data UInstBodyDecl dom stage + = UInstBodyNormalDecl { _instBodyDeclFunbind :: Ann UValueBind dom stage + } -- ^ A normal value binding (@ f x = 12 @) + | UInstBodyTypeSig { _instBodyTypeSig :: Ann UTypeSignature dom stage + } -- ^ Type signature in instance definition with @InstanceSigs@ + | UInstBodyTypeDecl { _instBodyTypeEqn :: Ann UTypeEqn dom stage + } -- ^ An associated type definition (@ type A X = B @) + | UInstBodyDataDecl { _instBodyDataNew :: Ann UDataOrNewtypeKeyword dom stage + , _instBodyLhsType :: Ann UInstanceRule dom stage + , _instBodyDataCons :: AnnListG UConDecl dom stage + , _instBodyDerivings :: AnnMaybeG UDeriving dom stage + } -- ^ An associated data type implementation (@ data A X = C1 | C2 @) + | UInstBodyGadtDataDecl { _instBodyDataNew :: Ann UDataOrNewtypeKeyword dom stage + , _instBodyLhsType :: Ann UInstanceRule dom stage + , _instBodyDataKind :: AnnMaybeG UKindConstraint dom stage + , _instBodyGadtCons :: AnnListG UGadtConDecl dom stage + , _instBodyDerivings :: AnnMaybeG UDeriving dom stage + } -- ^ An associated data type implemented using GADT style + | USpecializeInstance { _specializeInstanceType :: Ann UType dom stage + } -- ^ Specialize instance pragma (no phase selection is allowed) + -- not supported yet + -- | UInstBodyPatSyn { _instBodyPatSyn :: Ann UPatternSynonym dom stage + -- } -- ^ A pattern synonym in a class instance + +-- | Overlap pragmas. Can be applied to class declarations and class instance declarations. +data UOverlapPragma dom stage + = UEnableOverlap -- ^ @OVERLAP@ pragma + | UDisableOverlap -- ^ @NO_OVERLAP@ pragma + | UOverlappable -- ^ @OVERLAPPABLE@ pragma + | UOverlapping -- ^ @OVERLAPPING@ pragma + | UOverlaps -- ^ @OVERLAPS@ pragma + | UIncoherentOverlap -- ^ @INCOHERENT@ pragma + +-- * Type families + +-- | Open type and data families +data UTypeFamily dom stage + = UTypeFamily { _tfHead :: Ann UDeclHead dom stage + , _tfSpec :: AnnMaybeG UTypeFamilySpec dom stage + } -- ^ Type family declaration (@ type family A a :: * -> * @) + | UDataFamily { _tfHead :: Ann UDeclHead dom stage + , _tfKind :: AnnMaybeG UKindConstraint dom stage + } -- ^ Data family declaration (@ data family A a :: * -> * @) + +-- | Type family specification with kinds specification and injectivity. +data UTypeFamilySpec dom stage + = UTypeFamilyKind { _tfSpecKind :: Ann UKindConstraint dom stage + } -- ^ Specifies the kind of a type family (@ :: * -> * @) + | UTypeFamilyInjectivity { _tfInjectivity :: Ann UInjectivityAnn dom stage + } -- ^ Specifies the injectivity of a type family (@ = r | r -> a @) + +-- | Injectivity annotation for type families (@ = r | r -> a @) +data UInjectivityAnn dom stage + = UInjectivityAnn { _injAnnRes :: Ann UName dom stage + , _injAnnDeps :: AnnListG UName dom stage + } + +-- | Type equations as found in closed type families (@ T A = S @) +data UTypeEqn dom stage + = UTypeEqn { _teLhs :: Ann UType dom stage + , _teRhs :: Ann UType dom stage + } + +-- * Type definitions + +-- | GADT constructor declaration (@ D1 :: { val :: Int } -> T String @) +data UGadtConDecl dom stage + = UGadtConDecl { _gadtConNames :: AnnListG UName dom stage + , _gadtConType :: Ann UGadtConType dom stage + } + +-- | The @data@ or the @newtype@ keyword to define ADTs. +data UDataOrNewtypeKeyword dom stage + = UDataKeyword + | UNewtypeKeyword + +-- | Type of GADT constructors (can be record types: @{ val :: Int }@) +data UGadtConType dom stage + = UGadtNormalType { _gadtConNormalType :: Ann UType dom stage + } + | UGadtRecordType { _gadtConRecordFields :: AnnListG UFieldDecl dom stage + , _gadtConResultType :: Ann UType dom stage + } + +-- | A list of functional dependencies: @ | a -> b, c -> d @ separated by commas +data UFunDeps dom stage + = UFunDeps { _funDeps :: AnnListG UFunDep dom stage + } + +-- | A functional dependency, given on the form @l1 ... ln -> r1 ... rn@ +data UFunDep dom stage + = UFunDep { _funDepLhs :: AnnListG UName dom stage + , _funDepRhs :: AnnListG UName dom stage + } + +-- | A constructor declaration for a datatype +data UConDecl dom stage + = UConDecl { _conDeclName :: Ann UName dom stage + , _conDeclArgs :: AnnListG UType dom stage + } -- ^ Ordinary data constructor (@ C t1 t2 @) + | URecordDecl { _conDeclName :: Ann UName dom stage + , _conDeclFields :: AnnListG UFieldDecl dom stage + } -- ^ Record data constructor (@ C { _n1 :: t1, _n2 :: t2 } @) + | UInfixConDecl { _conDeclLhs :: Ann UType dom stage + , _conDeclOp :: Ann UOperator dom stage + , _conDeclRhs :: Ann UType dom stage + } -- ^ Infix data constructor (@ t1 :+: t2 @) + +-- | Field declaration (@ fld :: Int @) +data UFieldDecl dom stage + = UFieldDecl { _fieldNames :: AnnListG UName dom stage + , _fieldType :: Ann UType dom stage + } + +-- | A deriving clause following a data type declaration. (@ deriving Show @ or @ deriving (Show, Eq) @) +data UDeriving dom stage + = UDerivingOne { _oneDerived :: Ann UInstanceHead dom stage } + | UDerivings { _allDerived :: AnnListG UInstanceHead dom stage } + +-- * Pattern synonyms + +-- | Pattern type signature declaration (@ pattern Succ :: Int -> Int @) +data UPatternTypeSignature dom stage + = UPatternTypeSignature { _patSigName :: Ann UName dom stage + , _patSigType :: Ann UType dom stage + } + +-- | Pattern synonyms: @ pattern Arrow t1 t2 = App "->" [t1, t2] @ +data UPatternSynonym dom stage + = UPatternSynonym { _patLhs :: Ann UPatSynLhs dom stage + , _patRhs :: Ann UPatSynRhs dom stage + } + +-- | Left hand side of a pattern synonym +data UPatSynLhs dom stage + = UNormalPatSyn { _patName :: Ann UName dom stage + , _patArgs :: AnnListG UName dom stage + } -- ^ A left hand side with a constructor name and arguments (@ Arrow t1 t2 @) + | UInfixPatSyn { _patSynLhs :: Ann UName dom stage + , _patSynOp :: Ann UOperator dom stage + , _patSynRhs :: Ann UName dom stage + } -- ^ An infix pattern synonym left-hand side (@ t1 :+: t2 @) + | URecordPatSyn { _patName :: Ann UName dom stage + , _patArgs :: AnnListG UName dom stage + } -- ^ A record-style pattern synonym left-hand side (@ Arrow { arrowFrom, arrowTo } @) + +-- | Right-hand side of pattern synonym +data UPatSynRhs dom stage + -- TODO: this feels bad, changing _patRhsOpposite may switch between <- and = + = UBidirectionalPatSyn { _patRhsPat :: Ann UPattern dom stage + , _patRhsOpposite :: AnnMaybeG UPatSynWhere dom stage + } -- ^ @ pattern Int = App "Int" [] @ or @ pattern Int <- App "Int" [] where Int = App "Int" [] @ + | UOneDirectionalPatSyn { _patRhsPat :: Ann UPattern dom stage + } -- ^ @ pattern Int <- App "Int" [] @ + +-- | Where clause of pattern synonym (explicit expression direction) +data UPatSynWhere dom stage + = UPatSynWhere { _patOpposite :: AnnListG UMatch dom stage } + +-- * Foreign imports + +-- | Call conventions of foreign functions +data UCallConv dom stage + = UStdCall + | UCCall + | UCPlusPlus + | UDotNet + | UJvm + | UJs + | UJavaScript + | UCApi + +-- | Safety annotations for foreign calls +data USafety dom stage + = USafe + | UThreadSafe + | UUnsafe + | UInterruptible + +-- * Role annotations + +-- | Role annotations for types +data URole dom stage + = UNominal + | URepresentational + | UPhantom + +-- * Rewrite rules + +-- | Controls the activation of a rewrite rule (@ [1] @) +data UPhaseControl dom stage + = UPhaseControl { _phaseUntil :: AnnMaybeG PhaseInvert dom stage + , _phaseNumber :: Ann PhaseNumber dom stage + } + +-- | Phase number for rewrite rules +data PhaseNumber dom stage + = PhaseNumber { _phaseNum :: Integer } + +-- | A tilde that marks the inversion of the phase number +data PhaseInvert dom stage = PhaseInvert + +-- * Pragmas + +-- | Top level pragmas +data UTopLevelPragma dom stage + = URulePragma { _pragmaRule :: AnnListG URule dom stage + } -- ^ A pragma that introduces source rewrite rules (@ {-# RULES "map/map" [2] forall f g xs. map f (map g xs) = map (f.g) xs #-} @) + | UDeprPragma { _pragmaObjects :: AnnListG UName dom stage + , _pragmaMessage :: Ann UStringNode dom stage + } -- ^ A pragma that marks definitions as deprecated (@ {-# DEPRECATED f "f will be replaced by g" @) + | UWarningPragma { _pragmaObjects :: AnnListG UName dom stage + , _pragmaMessage :: Ann UStringNode dom stage + } -- ^ A pragma that marks definitions as deprecated (@ {-# WARNING unsafePerformIO "you should know what you are doing" @) + | UAnnPragma { _annotationSubject :: Ann UAnnotationSubject dom stage + , _annotateExpr :: Ann UExpr dom stage + } -- ^ A pragma that annotates a definition with an arbitrary value (@ {-# ANN f 42 @) + | UInlinePragma { _pragmaConlike :: AnnMaybeG UConlikeAnnot dom stage + , _pragmaPhase :: AnnMaybeG UPhaseControl dom stage + , _inlineDef :: Ann UName dom stage + } -- ^ A pragma that marks a function for inlining to the compiler (@ {-# INLINE thenUs #-} @) + | UNoInlinePragma { _pragmaConlike :: AnnMaybeG UConlikeAnnot dom stage + , _pragmaPhase :: AnnMaybeG UPhaseControl dom stage + , _noInlineDef :: Ann UName dom stage + } -- ^ A pragma that forbids a function from being inlined by the compiler (@ {-# NOINLINE f #-} @) + | UInlinablePragma { _pragmaPhase :: AnnMaybeG UPhaseControl dom stage + , _inlinableDef :: Ann UName dom stage + } -- ^ A pragma that marks a function that it may be inlined by the compiler (@ {-# INLINABLE thenUs #-} @) + | ULinePragma { _pragmaLineNum :: Ann LineNumber dom stage + , _pragmaFileName :: AnnMaybeG UStringNode dom stage + } -- ^ A pragma for maintaining line numbers in generated sources (@ {-# LINE 123 "somefile" #-} @) + | USpecializePragma { _pragmaPhase :: AnnMaybeG UPhaseControl dom stage + , _specializeDef :: Ann UName dom stage + , _specializeType :: AnnListG UType dom stage + } -- ^ A pragma that tells the compiler that a polymorph function should be optimized for a given type (@ {-# SPECIALISE f :: Int -> b -> b #-} @) + +-- | A rewrite rule (@ "map/map" forall f g xs. map f (map g xs) = map (f.g) xs @) +data URule dom stage + = URule { _ruleName :: Ann UStringNode dom stage -- ^ User name of the rule + , _rulePhase :: AnnMaybeG UPhaseControl dom stage -- ^ The compilation phases in which the rule can be applied + , _ruleBounded :: AnnListG UTyVar dom stage -- ^ Variables bound in the rule + , _ruleLhs :: Ann UExpr dom stage -- ^ The transformed expression + , _ruleRhs :: Ann UExpr dom stage -- ^ The resulting expression + } + +-- | Annotation allows you to connect an expression to any declaration. +data UAnnotationSubject dom stage + = UNameAnnotation { _annotateName :: Ann UName dom stage + } -- ^ The definition with the given name is annotated + | UTypeAnnotation { _annotateName :: Ann UName dom stage + } -- ^ A type with the given name is annotated + | UModuleAnnotation -- ^ The whole module is annotated + +-- | Formulas of minimal annotations declaring which functions should be defined. +data UMinimalFormula dom stage + = UMinimalName { _minimalName :: Ann UName dom stage + } + | UMinimalParen { _minimalInner :: Ann UMinimalFormula dom stage + } + | UMinimalOr { _minimalOrs :: AnnListG UMinimalFormula dom stage + } -- ^ One of the minimal formulas are needed (@ min1 | min2 @) + | UMinimalAnd { _minimalAnds :: AnnListG UMinimalFormula dom stage + } -- ^ Both of the minimal formulas are needed (@ min1 , min2 @) + +-- | A @CONLIKE@ modifier for an @INLINE@ pragma. +data UConlikeAnnot dom stage = UConlikeAnnot + +-- | A line number for a line pragma. +data LineNumber dom stage + = LineNumber { _lineNumber :: Int } diff --git a/Language/Haskell/Tools/AST/Representation/Exprs.hs b/Language/Haskell/Tools/AST/Representation/Exprs.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Exprs.hs @@ -0,0 +1,227 @@ +-- | Representation of Haskell expressions +module Language.Haskell.Tools.AST.Representation.Exprs where + +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Stmts +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Binds (ULocalBind, ULocalBinds, URhsGuard) + +-- | Haskell expressions +data UExpr dom stage + = UVar { _exprName :: Ann UName dom stage + } -- ^ A variable or a data constructor (@ a @) + | ULit { _exprLit :: Ann ULiteral dom stage + } -- ^ Literal expression (@ 42 @) + | UInfixApp { _exprLhs :: Ann UExpr dom stage + , _exprOperator :: Ann UOperator dom stage + , _exprRhs :: Ann UExpr dom stage + } -- ^ An infix operator application (@ a + b @) + | UPrefixApp { _exprOperator :: Ann UOperator dom stage + , _exprRhs :: Ann UExpr dom stage + } -- ^ Prefix operator application (@ -x @) + | UApp { _exprFun :: Ann UExpr dom stage + , _exprArg :: Ann UExpr dom stage + } -- ^ Function application (@ f 4 @) + | ULambda { _exprBindings :: AnnListG UPattern dom stage -- ^ at least one + , _exprInner :: Ann UExpr dom stage + } -- ^ Lambda expression (@ \a b -> a + b @) + | ULet { _exprFunBind :: AnnListG ULocalBind dom stage -- ^ nonempty + , _exprInner :: Ann UExpr dom stage + } -- ^ Local binding (@ let x = 2; y = 3 in e x y @) + | UIf { _exprCond :: Ann UExpr dom stage + , _exprThen :: Ann UExpr dom stage + , _exprElse :: Ann UExpr dom stage + } -- ^ If expression (@ if a then b else c @) + | UMultiIf { _exprIfAlts :: AnnListG UGuardedCaseRhs dom stage + } -- ^ Multi way if expressions with @MultiWayIf@ extension (@ if | guard1 -> expr1; guard2 -> expr2 @) + | UCase { _exprCase :: Ann UExpr dom stage + , _exprAlts :: AnnListG UAlt dom stage + } -- ^ Pattern matching expression (@ case expr of pat1 -> expr1; pat2 -> expr2 @) + | UDo { _doKind :: Ann UDoKind dom stage + , _exprStmts :: AnnListG UStmt dom stage + } -- ^ Do-notation expressions (@ do x <- act1; act2 @) + | UTuple { _tupleElems :: AnnListG UExpr dom stage + } -- ^ Tuple expression (@ (e1, e2, e3) @) + | UUnboxedTuple { _tupleElems :: AnnListG UExpr dom stage + } -- ^ Unboxed tuple expression (@ (# e1, e2, e3 #) @) + | UTupleSection { _tupleSectionElems :: AnnListG UTupSecElem dom stage + } -- ^ Tuple section, enabled with @TupleSections@ (@ (a,,b) @). One of the elements must be missing. + | UUnboxedTupSec { _tupleSectionElems :: AnnListG UTupSecElem dom stage + } -- ^ Unboxed tuple section enabled with @TupleSections@ (@ (# a,,b #) @). One of the elements must be missing. + | UList { _listElems :: AnnListG UExpr dom stage + } -- ^ List expression: @[1,2,3]@ + | UParArray { _listElems :: AnnListG UExpr dom stage + } -- ^ Parallel array expression: @[: 1,2,3 :]@ + | UParen { _exprInner :: Ann UExpr dom stage + } -- ^ Parenthesized expression: @( a + b )@ + | ULeftSection { _exprLhs :: Ann UExpr dom stage + , _exprOperator :: Ann UOperator dom stage + } -- ^ Left operator section: @(1+)@ + | URightSection { _exprOperator :: Ann UOperator dom stage + , _exprRhs :: Ann UExpr dom stage + } -- ^ Right operator section: @(+1)@ + | URecCon { _exprRecName :: Ann UName dom stage + , _exprRecFields :: AnnListG UFieldUpdate dom stage + } -- ^ Record value construction: @Point { x = 3, y = -2 }@ + | URecUpdate { _exprInner :: Ann UExpr dom stage + , _exprRecFields :: AnnListG UFieldUpdate dom stage + } -- ^ Record value update: @p1 { x = 3, y = -2 }@ + | UEnum { _enumFrom :: Ann UExpr dom stage + , _enumThen :: AnnMaybeG UExpr dom stage + , _enumTo :: AnnMaybeG UExpr dom stage + } -- ^ Enumeration expression (@ [1,3..10] @) + | UParArrayEnum { _enumFrom :: Ann UExpr dom stage + , _enumThen :: AnnMaybeG UExpr dom stage + , _enumToFix :: Ann UExpr dom stage + } -- ^ Parallel array enumeration (@ [: 1,3 .. 10 :] @) + | UListComp { _compExpr :: Ann UExpr dom stage + , _compBody :: AnnListG UListCompBody dom stage -- ^ Can only have 1 element without @ParallelListComp@ + } -- ^ List comprehension (@ [ (x, y) | x <- xs | y <- ys ] @) + | UParArrayComp { _compExpr :: Ann UExpr dom stage + , _compBody :: AnnListG UListCompBody dom stage + } -- ^ Parallel array comprehensions @ [: (x, y) | x <- xs , y <- ys :] @ enabled by @ParallelArrays@ + | UTypeSig { _exprInner :: Ann UExpr dom stage + , _exprSig :: Ann UType dom stage + } -- ^ Explicit type signature (@ x :: Int @) + | UExplTypeApp { _exprInner :: Ann UExpr dom stage + , _exprType :: Ann UType dom stage + } -- ^ Explicit type application (@ show \@Integer (read "5") @) + | UVarQuote { _quotedName :: Ann UName dom stage + } -- ^ @'x@ for template haskell reifying of expressions + | UTypeQuote { _quotedName :: Ann UName dom stage + } -- ^ @''T@ for template haskell reifying of types + | UBracketExpr { _exprBracket :: Ann UBracket dom stage + } -- ^ Template haskell bracket expression + | USplice { _exprSplice :: Ann USplice dom stage + } -- ^ Template haskell splice expression, for example: @$(gen a)@ or @$x@ + | UQuasiQuoteExpr { _exprQQ :: Ann UQuasiQuote dom stage + } -- ^ Template haskell quasi-quotation: @[$quoter|str]@ + | UExprPragma { _exprPragma :: Ann UExprPragma dom stage + , _innerExpr :: Ann UExpr dom stage + } + -- Arrows + | UProc { _procPattern :: Ann UPattern dom stage + , _procExpr :: Ann UCmd dom stage + } -- ^ Arrow definition: @proc a -> f -< a+1@ + | UArrowApp { _exprLhs :: Ann UExpr dom stage + , _arrowAppl :: Ann UArrowAppl dom stage + , _exprRhs :: Ann UExpr dom stage + } -- ^ Arrow application: @f -< a+1@ + | ULamCase { _exprAlts :: AnnListG UAlt dom stage + } -- ^ Lambda case ( @\case 0 -> 1; 1 -> 2@ ) + | UStaticPtr { _exprInner :: Ann UExpr dom stage + } -- ^ Static pointer expression (@ static e @). The inner expression must be closed (cannot have variables bound outside) + -- XML expressions omitted + +-- | Field update expressions +data UFieldUpdate dom stage + = UNormalFieldUpdate { _fieldName :: Ann UName dom stage + , _fieldValue :: Ann UExpr dom stage + } -- ^ Update of a field (@ x = 1 @) + | UFieldPun { _fieldUpdateName :: Ann UName dom stage + } -- ^ Update the field to the value of the same name (@ x @) + | UFieldWildcard { _fieldWildcard :: Ann UFieldWildcard dom stage + } -- ^ Update the fields of the bounded names to their values (@ .. @). Must be the last initializer. Cannot be used in a record update expression. + +-- | Marker for a field wildcard. Only needed to attach semantic information in a type-safe way. +data UFieldWildcard dom stage = FldWildcard + +-- | An element of a tuple section that can be an expression or missing (indicating a value from a parameter) +data UTupSecElem dom stage + = Present { _tupSecExpr :: Ann UExpr dom stage + } -- ^ An existing element in a tuple section + | Missing -- ^ A missing element in a tuple section + +-- | Clause of case expression (@ Just x -> x + 1 @) +data UAlt' expr dom stage + = UAlt { _altPattern :: Ann UPattern dom stage + , _altRhs :: Ann (UCaseRhs' expr) dom stage + , _altBinds :: AnnMaybeG ULocalBinds dom stage + } +type UAlt = UAlt' UExpr +type UCmdAlt = UAlt' UCmd + + +-- | Right hand side of a match (possible with guards): (@ -> 3 @ or @ | x == 1 -> 3; | otherwise -> 4 @) +data UCaseRhs' expr dom stage + = UUnguardedCaseRhs { _rhsCaseExpr :: Ann expr dom stage + } -- ^ Unguarded right-hand side a pattern match (@ -> 3 @) + | UGuardedCaseRhss { _rhsCaseGuards :: AnnListG (UGuardedCaseRhs' expr) dom stage + } -- ^ Guarded right-hand sides of a pattern match (@ | x == 1 -> 3; | otherwise -> 4 @) +type UCaseRhs = UCaseRhs' UExpr +type UCmdCaseRhs = UCaseRhs' UCmd + +-- | A guarded right-hand side of pattern matches binding (@ | x > 3 -> 2 @) +data UGuardedCaseRhs' expr dom stage + = UGuardedCaseRhs { _caseGuardStmts :: AnnListG URhsGuard dom stage -- ^ Cannot be empty. + , _caseGuardExpr :: Ann expr dom stage + } +type UGuardedCaseRhs = UGuardedCaseRhs' UExpr +type UCmdGuardedCaseRhs = UGuardedCaseRhs' UCmd + +-- | Pragmas that can be applied to expressions +data UExprPragma dom stage + = UCorePragma { _pragmaStr :: Ann UStringNode dom stage + } -- ^ A @CORE@ pragma for adding notes to expressions. + | USccPragma { _pragmaStr :: Ann UStringNode dom stage + } -- ^ An @SCC@ pragma for defining cost centers for profiling + | UGeneratedPragma { _pragmaSrcRange :: Ann USourceRange dom stage + } -- ^ A pragma that describes if an expression was generated from a code fragment by an external tool (@ {-# GENERATED "Happy.y" 1:15-1:25 #-} @) + +-- | In-AST source ranges (for generated pragmas) +data USourceRange dom stage + = USourceRange { _srFileName :: Ann UStringNode dom stage + , _srFromLine :: Ann Number dom stage + , _srFromCol :: Ann Number dom stage + , _srToLine :: Ann Number dom stage + , _srToCol :: Ann Number dom stage + } + +data Number dom stage + = Number { _numberInteger :: Integer + } + +-- * Arrows + +data UCmd dom stage + = UArrowAppCmd { _cmdLhs :: Ann UExpr dom stage + , _cmdArrowOp :: Ann UArrowAppl dom stage + , _cmdRhs :: Ann UExpr dom stage + } -- ^ An arrow application command (@ f -< x + 1 @) + | UArrowFormCmd { _cmdExpr :: Ann UExpr dom stage + , _cmdInnerCmds :: AnnListG UCmd dom stage + } -- ^ A form command (@ (|untilA (increment -< x+y) (within 0.5 -< x)|) @) + | UAppCmd { _cmdInnerCmd :: Ann UCmd dom stage + , _cmdApplied :: Ann UExpr dom stage + } -- ^ A function application command + | UInfixCmd { _cmdLeftCmd :: Ann UCmd dom stage + , _cmdOperator :: Ann UName dom stage + , _cmdRightCmd :: Ann UCmd dom stage + } -- ^ An infix command application + | ULambdaCmd { _cmdBindings :: AnnListG UPattern dom stage -- ^ at least one + , _cmdInner :: Ann UCmd dom stage + } -- ^ A lambda command + | UParenCmd { _cmdInner :: Ann UCmd dom stage + } -- ^ A parenthesized command + | UCaseCmd { _cmdExpr :: Ann UExpr dom stage + , _cmdAlts :: AnnListG UCmdAlt dom stage + } -- ^ A pattern match command + | UIfCmd { _cmdExpr :: Ann UExpr dom stage + , _cmdThen :: Ann UCmd dom stage + , _cmdElse :: Ann UCmd dom stage + } -- ^ An if command (@ if f x y then g -< x+1 else h -< y+2 @) + | ULetCmd { _cmdBinds :: AnnListG ULocalBind dom stage -- ^ nonempty + , _cmdInner :: Ann UCmd dom stage + } -- ^ A local binding command (@ let z = x+y @) + | UDoCmd { _cmdStmts :: AnnListG UCmdStmt dom stage + } -- ^ A do-notation in a command + +data UArrowAppl dom stage + = ULeftAppl -- ^ Left arrow application: @-<@ + | URightAppl -- ^ Right arrow application: @>-@ + | ULeftHighApp -- ^ Left arrow high application: @-<<@ + | URightHighApp -- ^ Right arrow high application: @>>-@ diff --git a/Language/Haskell/Tools/AST/Representation/Exprs.hs-boot b/Language/Haskell/Tools/AST/Representation/Exprs.hs-boot new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Exprs.hs-boot @@ -0,0 +1,11 @@ +{-# LANGUAGE RoleAnnotations #-} +module Language.Haskell.Tools.AST.Representation.Exprs where + +type role UExpr nominal nominal +data UExpr dom stage + +type role UCmd nominal nominal +data UCmd dom stage + +type role UFieldWildcard phantom phantom +data UFieldWildcard dom stage diff --git a/Language/Haskell/Tools/AST/Representation/Kinds.hs b/Language/Haskell/Tools/AST/Representation/Kinds.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Kinds.hs @@ -0,0 +1,43 @@ +-- | Representation of Haskell Kinds +module Language.Haskell.Tools.AST.Representation.Kinds where + +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Names + +-- | Kind constraint (@ :: * -> * @) +data UKindConstraint dom stage + = UKindConstraint { _kindConstr :: Ann UKind dom stage + } + +-- | Haskell kinds +data UKind dom stage + = UStarKind -- ^ @*@, the kind of types + | UUnboxKind -- ^ @#@, the kind of unboxed types + | UFunKind { _kindLeft :: Ann UKind dom stage + , _kindRight :: Ann UKind dom stage + } -- ^ @->@, the kind of type constructor + | UParenKind { _kindParen :: Ann UKind dom stage + } -- ^ A parenthesised kind + | UVarKind { _kindVar :: Ann UName dom stage + } -- ^ Kind variable (using @PolyKinds@ extension) + | UAppKind { _kindAppFun :: Ann UKind dom stage + , _kindAppArg :: Ann UKind dom stage + } -- ^ Kind application (@ k1 k2 @) + | UListKind { _kindElem :: Ann UKind dom stage + } -- ^ A list kind (@ [k] @) + | UPromotedKind { _kindPromoted :: Ann (UPromoted UKind) dom stage + } -- ^ A promoted kind (@ '(k1,k2,k3) @) + +data UPromoted t dom stage + = UPromotedInt { _promotedIntValue :: Integer + } -- ^ Numeric value promoted to the kind level. + | UPromotedString { _promotedStringValue :: String + } -- ^ String value promoted to the kind level. + | UPromotedCon { _promotedConName :: Ann UName dom stage + } -- ^ A data constructor value promoted to the kind level. + | UPromotedList { _promotedElements :: AnnListG t dom stage + } -- ^ A list of elements as a kind. + | UPromotedTuple { _promotedElements :: AnnListG t dom stage + } -- ^ A tuple of elements as a kind. + | UPromotedUnit -- ^ Kind of the unit value @()@. diff --git a/Language/Haskell/Tools/AST/Representation/Literals.hs b/Language/Haskell/Tools/AST/Representation/Literals.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Literals.hs @@ -0,0 +1,29 @@ +-- | Representation of Haskell literals +module Language.Haskell.Tools.AST.Representation.Literals where + +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Names + +-- | Haskell literals +data ULiteral dom stage + = UCharLit { _charLitValue :: Char + } -- ^ Character literal: @'c'@ + | UStringLit { _stringLitValue :: String + } -- ^ String literal: @"abc"@ + | UIntLit { _intLitValue :: Integer + } -- ^ Integer literal: @12@ + | UFracLit { _fracLitValue :: Rational + } -- ^ Fractional literal: @3.14@ + | UPrimIntLit { _intLitValue :: Integer + } -- ^ Primitive integer literal (of type @Int#@): @32#@ + | UPrimWordLit { _intLitValue :: Integer + } -- ^ Primitive word literal (of type @Word#@): @32##@ + | UPrimFloatLit { _floatLitValue :: Rational + } -- ^ Primitive float literal (of type @Float#@): @3.14#@ + | UPrimDoubleLit { _floatLitValue :: Rational + } -- ^ Primitive double literal (of type @Double#@): @3.14##@ + | UPrimCharLit { _charLitValue :: Char + } -- ^ Primitive character literal (of type @Char#@): @'c'#@ + | UPrimStringLit { _stringLitValue :: String + } -- ^ Primitive string literal (of type @Addr#@): @"xxx"#@ + diff --git a/Language/Haskell/Tools/AST/Representation/Modules.hs b/Language/Haskell/Tools/AST/Representation/Modules.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Modules.hs @@ -0,0 +1,103 @@ +-- | Representation of Haskell modules, imports and exports. Also contains file-level pragmas. +module Language.Haskell.Tools.AST.Representation.Modules where + +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Decls + +-- | The representation of a haskell module, that is a separate compilation unit. +-- It may or may not have a header. +data UModule dom stage + = UModule { _filePragmas :: AnnListG UFilePragma dom stage + , _modHead :: AnnMaybeG UModuleHead dom stage + , _modImports :: AnnListG UImportDecl dom stage + , _modDecl :: AnnListG UDecl dom stage + } + +-- | Module declaration with name and (optional) exports +data UModuleHead dom stage + = UModuleHead { _mhName :: Ann UModuleName dom stage + , _mhExports :: AnnMaybeG UExportSpecs dom stage + , _mhPragma :: AnnMaybeG UModulePragma dom stage + } + +-- | A list of export specifications surrounded by parentheses +data UExportSpecs dom stage + = UExportSpecs { _espExports :: AnnListG UExportSpec dom stage } + +-- | Export specifier +data UExportSpec dom stage + = UDeclExport { _exportDecl :: Ann UIESpec dom stage + } -- ^ Export a name and related names + | UModuleExport { _exportModuleName :: Ann UModuleName dom stage + } -- ^ The export of an imported module (@ module A @) + +-- | Marks a name to be imported or exported with related names (subspecifier) +data UIESpec dom stage + = UIESpec { _ieName :: Ann UName dom stage + , _ieSubspec :: AnnMaybeG USubSpec dom stage + } + +-- | Marks how related names will be imported or exported with a given name +data USubSpec dom stage + = USubSpecAll -- ^ @(..)@: a class exported with all of its methods, or a datatype exported with all of its constructors. + | USubSpecList { _essList :: AnnListG UName dom stage + } -- ^ @(a,b,c)@: a class exported with some of its methods, or a datatype exported with some of its constructors. + +-- | Pragmas that must be used before defining the module +data UFilePragma dom stage + = ULanguagePragma { _lpPragmas :: AnnListG ULanguageExtension dom stage + } -- ^ @LANGUAGE@ pragma, listing the enabled language extensions in that file + | UOptionsPragma { _opStr :: Ann UStringNode dom stage + } -- ^ @OPTIONS@ pragma, possibly qualified with a tool, e.g. OPTIONS_GHC + +-- | Pragmas that must be used after the module head +data UModulePragma dom stage + = UModuleWarningPragma { _modWarningStr :: AnnListG UStringNode dom stage + } -- ^ A warning pragma attached to the module + | UModuleDeprecatedPragma { _modDeprecatedPragma :: AnnListG UStringNode dom stage + } -- ^ A deprecated pragma attached to the module + +-- | The name of the enabled language extension, for example (@ LambdaCase @) +data ULanguageExtension dom stage = ULanguageExtension { _langExt :: String } + +-- | An import declaration: @import Module.Name@ +data UImportDecl dom stage + = UImportDecl { _importSource :: AnnMaybeG UImportSource dom stage + , _importQualified :: AnnMaybeG UImportQualified dom stage + , _importSafe :: AnnMaybeG UImportSafe dom stage + , _importPkg :: AnnMaybeG UStringNode dom stage + , _importModule :: Ann UModuleName dom stage + , _importAs :: AnnMaybeG UImportRenaming dom stage + , _importSpec :: AnnMaybeG UImportSpec dom stage + } + +-- | Restriction on the imported names +data UImportSpec dom stage + = UImportSpecList { _importSpecList :: AnnListG UIESpec dom stage + } -- ^ Restrict the import definition to ONLY import the listed names + | UImportSpecHiding { _importSpecHiding :: AnnListG UIESpec dom stage + } -- ^ Restrict the import definition to DONT import the listed names + +-- | Marks the import as qualified: @qualified@ +data UImportQualified dom stage = UImportQualified + +-- | Marks the import as source: @{-# SOURCE #-}@ +data UImportSource dom stage = UImportSource + +-- | Marks the import as safe: @safe@ +data UImportSafe dom stage = UImportSafe + +-- | Marks an imported name to belong to the type namespace: @type@ +data UTypeNamespace dom stage = UTypeNamespace + +-- | Renaming imports (@ as A @) +data UImportRenaming dom stage = UImportRenaming { _importRename :: Ann UModuleName dom stage } + +-- | The name of a module +data UModuleName dom stage = UModuleName { _moduleNameString :: String } + +-- | The @type@ keyword used to qualify that the type and not the constructor of the same name is referred +data TypeKeyword dom stage = TypeKeyword diff --git a/Language/Haskell/Tools/AST/Representation/Modules.hs-boot b/Language/Haskell/Tools/AST/Representation/Modules.hs-boot new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Modules.hs-boot @@ -0,0 +1,8 @@ +{-# LANGUAGE RoleAnnotations #-} +module Language.Haskell.Tools.AST.Representation.Modules where + +type role UModule nominal nominal +data UModule dom stage + +type role UImportDecl nominal nominal +data UImportDecl dom stage diff --git a/Language/Haskell/Tools/AST/Representation/Names.hs b/Language/Haskell/Tools/AST/Representation/Names.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Names.hs @@ -0,0 +1,44 @@ + +{-# LANGUAGE TypeFamilies + , MultiParamTypeClasses + , FlexibleInstances + #-} + +-- | Simple AST elements of Haskell +module Language.Haskell.Tools.AST.Representation.Names where + +import Language.Haskell.Tools.AST.Ann + +data UOperator dom stage + = UBacktickOp { _operatorName :: Ann UQualifiedName dom stage + } -- ^ A normal name used as an operator with backticks: @ a `mod` b @ + | UNormalOp { _operatorName :: Ann UQualifiedName dom stage + } -- ^ A normal operator used as an operator. + +data UName dom stage + = UParenName { _simpleName :: Ann UQualifiedName dom stage + } -- ^ Parenthesized name: @ foldl (+) 0 @ + | UNormalName { _simpleName :: Ann UQualifiedName dom stage + } -- ^ A normal, non-operator name. + | UImplicitName { _simpleName :: Ann UQualifiedName dom stage + } -- ^ Implicit name: @ ?var @ + +-- | Possible qualified names. Contains also implicit names. +-- Linear implicit parameter: @%x@. Non-linear implicit parameter: @?x@. +data UQualifiedName dom stage + = UQualifiedName { _qualifiers :: AnnListG UNamePart dom stage + , _unqualifiedName :: Ann UNamePart dom stage + } + +nameFromList :: AnnListG UNamePart dom stage -> UQualifiedName dom stage +nameFromList (AnnListG a xs) | not (null xs) + = UQualifiedName (AnnListG a (init xs)) (last xs) +nameFromList _ = error "nameFromList: empty list" + +-- | Parts of a qualified name. +data UNamePart dom stage + = UNamePart { _simpleNameStr :: String } + +-- | Program elements formatted as string literals (import packages, pragma texts) +data UStringNode dom stage + = UStringNode { _stringNodeStr :: String } diff --git a/Language/Haskell/Tools/AST/Representation/Names.hs-boot b/Language/Haskell/Tools/AST/Representation/Names.hs-boot new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Names.hs-boot @@ -0,0 +1,5 @@ +{-# LANGUAGE RoleAnnotations #-} +module Language.Haskell.Tools.AST.Representation.Names where + +type role UQualifiedName nominal nominal +data UQualifiedName dom stage diff --git a/Language/Haskell/Tools/AST/Representation/Patterns.hs b/Language/Haskell/Tools/AST/Representation/Patterns.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Patterns.hs @@ -0,0 +1,70 @@ +-- | Representation of Haskell patterns +module Language.Haskell.Tools.AST.Representation.Patterns where + +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Types +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UFieldWildcard) +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH + + +-- | Representation of patterns for pattern bindings +data UPattern dom stage + = UVarPat { _patternName :: Ann UName dom stage + } -- ^ Pattern name binding + | ULitPat { _patternLiteral :: Ann ULiteral dom stage + } -- ^ Literal pattern + | UInfixAppPat { _patternLhs :: Ann UPattern dom stage + , _patternOperator :: Ann UOperator dom stage + , _patternRhs :: Ann UPattern dom stage + } -- ^ Infix constructor application pattern (@ a :+: b @) + | UAppPat { _patternName :: Ann UName dom stage + , _patternArgs :: AnnListG UPattern dom stage + } -- ^ Constructor application pattern (@ Point x y @) + | UTuplePat { _patternElems :: AnnListG UPattern dom stage + } -- ^ Tuple pattern (@ (x,y) @) + | UUnboxTuplePat { _patternElems :: AnnListG UPattern dom stage + } -- ^ Unboxed tuple pattern (@ (# x, y #) @) + | UListPat { _patternElems :: AnnListG UPattern dom stage + } -- ^ List pattern (@ [1,2,a,x] @) + | UParArrPat { _patternElems :: AnnListG UPattern dom stage + } -- ^ Parallel array pattern (@ [:1,2,a,x:] @) + | UParenPat { _patternInner :: Ann UPattern dom stage + } -- ^ Parenthesised patterns + | URecPat { _patternName :: Ann UName dom stage + , _patternFields :: AnnListG UPatternField dom stage + } -- ^ Record pattern (@ Point { x = 3, y } @) + | UAsPat { _patternName :: Ann UName dom stage + , _patternInner :: Ann UPattern dom stage + } -- ^ As-pattern (explicit name binding) (@ ls\@(hd:_) @) + | UWildPat -- ^ Wildcard pattern: (@ _ @) + | UIrrefutablePat { _patternInner :: Ann UPattern dom stage + } -- ^ Irrefutable pattern (@ ~(x:_) @) + | UBangPat { _patternInner :: Ann UPattern dom stage + } -- ^ Bang pattern (@ !x @) + | UTypeSigPat { _patternInner :: Ann UPattern dom stage + , _patternType :: Ann UType dom stage + } -- ^ Pattern with explicit type signature (@ x :: Int @) + | UViewPat { _patternExpr :: Ann UExpr dom stage + , _patternInner :: Ann UPattern dom stage + } -- ^ View pattern (@ f -> Just 1 @) + -- regular list pattern omitted + -- xml patterns omitted + | USplicePat { _patternSplice :: Ann USplice dom stage + } -- ^ Splice patterns: @$(generateX inp)@ + | UQuasiQuotePat { _patQQ :: Ann UQuasiQuote dom stage + } -- ^ Quasi-quoted patterns: @[| 1 + 2 |]@ + | UNPlusKPat { _patternName :: Ann UName dom stage + , _patternLit :: Ann ULiteral dom stage + } + +-- Field specification of a record pattern +data UPatternField dom stage + = UNormalFieldPattern { _fieldPatternName :: Ann UName dom stage + , _fieldPattern :: Ann UPattern dom stage + } -- ^ Named field pattern (@ p = Point 3 2 @) + | UFieldPunPattern { _fieldPatternName :: Ann UName dom stage + } -- ^ Named field pun (@ p @) + | UFieldWildcardPattern { _fieldPatternWildcard :: Ann UFieldWildcard dom stage + } -- ^ Wildcard field pattern (@ .. @) diff --git a/Language/Haskell/Tools/AST/Representation/Stmts.hs b/Language/Haskell/Tools/AST/Representation/Stmts.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Stmts.hs @@ -0,0 +1,44 @@ +-- | Representation of Haskell statements (both do-notation and comprehensions) +module Language.Haskell.Tools.AST.Representation.Stmts where + +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Representation.Patterns +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UCmd) +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Binds (ULocalBind) + +-- | Normal monadic statements +data UStmt' expr dom stage + = UBindStmt { _stmtPattern :: Ann UPattern dom stage + , _stmtExpr :: Ann expr dom stage + } -- ^ Binding statement (@ x <- action @) + | UExprStmt { _stmtExpr :: Ann expr dom stage + } -- ^ Non-binding statement (@ action @) + | ULetStmt { _stmtBinds :: AnnListG ULocalBind dom stage + } -- ^ Let statement (@ let x = 3; y = 4 @) + | URecStmt { _cmdStmtBinds :: AnnListG (UStmt' expr) dom stage + } -- ^ A recursive binding statement with (@ rec b <- f a c; c <- f b a @) +type UStmt = UStmt' UExpr +type UCmdStmt = UStmt' UCmd + +-- | Body of a list comprehension: (@ | x <- [1..10] @) +data UListCompBody dom stage + = UListCompBody { _compStmts :: AnnListG UCompStmt dom stage + } + +-- | List comprehension statement +data UCompStmt dom stage + = UCompStmt { _compStmt :: Ann UStmt dom stage + } -- ^ Normal monadic statement of a list comprehension + | UThenStmt { _thenExpr :: Ann UExpr dom stage + , _byExpr :: AnnMaybeG UExpr dom stage + } -- ^ Then statements by @TransformListComp@ (@ then sortWith by (x + y) @) + | UGroupStmt { _byExpr :: AnnMaybeG UExpr dom stage + , _usingExpr :: AnnMaybeG UExpr dom stage + } -- ^ Grouping statements by @TransformListComp@ (@ then group by (x + y) using groupWith @) + -- Note: either byExpr or usingExpr must have a value + +-- | Keywords @do@ or @mdo@ to start a do-block +data UDoKind dom stage + = UDoKeyword + | UMDoKeyword diff --git a/Language/Haskell/Tools/AST/Representation/TH.hs b/Language/Haskell/Tools/AST/Representation/TH.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/TH.hs @@ -0,0 +1,41 @@ +-- | Representation of Template Haskell AST elements +module Language.Haskell.Tools.AST.Representation.TH where + +import Language.Haskell.Tools.AST.Representation.Decls +import Language.Haskell.Tools.AST.Representation.Binds +import Language.Haskell.Tools.AST.Representation.Exprs +import Language.Haskell.Tools.AST.Representation.Patterns +import Language.Haskell.Tools.AST.Representation.Types +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Ann + +-- | A template haskell splice +data USplice dom stage + = UIdSplice { _spliceId :: Ann UName dom stage + } -- ^ A simple name splice: @$generateX@ + | UParenSplice { _spliceExpr :: Ann UExpr dom stage + } -- ^ A splice with parentheses: @$(generate input)@ + +-- | Template haskell quasi-quotation: @[quoter|str]@ +data UQuasiQuote dom stage + = UQuasiQuote { _qqExprName :: Ann UName dom stage + , _qqExprBody :: Ann QQString dom stage + } + +-- | Template Haskell Quasi-quotation content +data QQString dom stage + = QQString { _qqString :: String + } + + +-- | Template Haskell bracket expressions +data UBracket dom stage + = UExprBracket { _bracketExpr :: Ann UExpr dom stage + } -- ^ Expression bracket (@ [| x + y |] @) + | UPatternBracket { _bracketPattern :: Ann UPattern dom stage + } -- ^ Pattern bracket (@ [p| Point x y |] @) + | UTypeBracket { _bracketType :: Ann UType dom stage + } -- ^ Type bracket (@ [t| (Int,Int) |] @) + | UDeclsBracket { _bracketDecl :: AnnListG UDecl dom stage + } -- ^ Declaration bracket (@ [d| f :: Int -> Int; f x = x*x |] @) + diff --git a/Language/Haskell/Tools/AST/Representation/TH.hs-boot b/Language/Haskell/Tools/AST/Representation/TH.hs-boot new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/TH.hs-boot @@ -0,0 +1,11 @@ +{-# LANGUAGE RoleAnnotations #-} +module Language.Haskell.Tools.AST.Representation.TH where + +type role USplice nominal nominal +data USplice dom stage + +type role UQuasiQuote nominal nominal +data UQuasiQuote dom stage + +type role UBracket nominal nominal +data UBracket dom stage diff --git a/Language/Haskell/Tools/AST/Representation/Types.hs b/Language/Haskell/Tools/AST/Representation/Types.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Tools/AST/Representation/Types.hs @@ -0,0 +1,87 @@ +-- | Representation of Haskell types +module Language.Haskell.Tools.AST.Representation.Types where + +import Language.Haskell.Tools.AST.Ann +import Language.Haskell.Tools.AST.Representation.Literals +import Language.Haskell.Tools.AST.Representation.Names +import Language.Haskell.Tools.AST.Representation.Kinds +import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH + +-- | Type variable declaration +data UTyVar dom stage + = UTyVarDecl { _tyVarName :: Ann UName dom stage + , _tyVarKind :: AnnMaybeG UKindConstraint dom stage + } + +-- | Haskell types +data UType dom stage + = UTyForall { _typeBounded :: AnnListG UTyVar dom stage + , _typeType :: Ann UType dom stage + } -- ^ Forall types (@ forall x y . type @) + | UTyCtx { _typeCtx :: Ann UContext dom stage + , _typeType :: Ann UType dom stage + } -- ^ Type with a context (@ forall x y . type @) + | UTyFun { _typeParam :: Ann UType dom stage + , _typeResult :: Ann UType dom stage + } -- ^ Function types (@ a -> b @) + | UTyTuple { _typeElements :: AnnListG UType dom stage + } -- ^ Tuple types (@ (a,b) @) + | UTyUnbTuple { _typeElements :: AnnListG UType dom stage + } -- ^ Unboxed tuple types (@ (#a,b#) @) + | UTyList { _typeElement :: Ann UType dom stage + } -- ^ List type with special syntax (@ [a] @) + | UTyParArray { _typeElement :: Ann UType dom stage + } -- ^ Parallel array type (@ [:a:] @) + | UTyApp { _typeCon :: Ann UType dom stage + , _typeArg :: Ann UType dom stage + } -- ^ Type application (@ F a @) + | UTyVar { _typeName :: Ann UName dom stage + } -- ^ Type variable or constructor (@ a @) + | UTyParen { _typeInner :: Ann UType dom stage + } -- ^ Type surrounded by parentheses (@ (T a) @) + | UTyInfix { _typeLeft :: Ann UType dom stage + , _typeOperator :: Ann UOperator dom stage + , _typeRight :: Ann UType dom stage + } -- ^ Infix type constructor (@ (a <: b) @) + | UTyKinded { _typeInner :: Ann UType dom stage + , _typeKind :: Ann UKind dom stage + } -- ^ Type with explicit kind signature (@ a :: * @) + | UTyPromoted { _tpPromoted :: Ann (UPromoted UType) dom stage + } -- A promoted data type with @-XDataKinds@ (@ 3 @, @ Left @, @ 'Left @). + | UTySplice { _tsSplice :: Ann USplice dom stage + } -- ^ A Template Haskell splice type (@ $(genType) @). + | UTyQuasiQuote { _typeQQ :: Ann UQuasiQuote dom stage + } -- ^ A Template Haskell quasi-quote type (@ [quoter| ... ] @). + | UTyBang { _typeInner :: Ann UType dom stage + } -- ^ Strict type marked with @!@. + | UTyLazy { _typeInner :: Ann UType dom stage + } -- ^ Lazy type marked with @~@. (Should only be used if @Strict@ or @StrictData@ language extension is used) + | UTyUnpack { _typeInner :: Ann UType dom stage + } -- ^ Strict type marked with UNPACK pragma. (Usually contains the bang mark.) + | UTyNoUnpack { _typeInner :: Ann UType dom stage + } -- ^ Strict type marked with NOUNPACK pragma. (Usually contains the bang mark.) + | UTyWildcard -- ^ A wildcard type (@ _ @) with @-XPartialTypeSignatures@ + | UTyNamedWildc { _typeWildcardName :: Ann UName dom stage + } -- ^ A named wildcard type (@ _t @) with @-XPartialTypeSignatures@ + +-- One or more assertions +data UContext dom stage + = UContextOne { _contextAssertion :: Ann UAssertion dom stage + } -- ^ One assertion (@ C a => ... @) + | UContextMulti { _contextAssertions :: AnnListG UAssertion dom stage + } -- ^ A set of assertions (@ (C1 a, C2 b) => ... @, but can be one: @ (C a) => ... @) + +-- | A single assertion in the context +data UAssertion dom stage + = UClassAssert { _assertClsName :: Ann UName dom stage + , _assertTypes :: AnnListG UType dom stage + } -- ^ Class assertion (@Cls x@) + | UInfixAssert { _assertLhs :: Ann UType dom stage + , _assertOp :: Ann UOperator dom stage + , _assertRhs :: Ann UType dom stage + } -- ^ Infix class assertion, also contains type equations (@ a ~ X y @) + | UImplicitAssert { _assertImplVar :: Ann UName dom stage + , _assertImplType :: Ann UType dom stage + } -- ^ Assertion for implicit parameter binding (@ ?cmp :: a -> a -> Bool @) + + diff --git a/Language/Haskell/Tools/AST/SemaInfoClasses.hs b/Language/Haskell/Tools/AST/SemaInfoClasses.hs --- a/Language/Haskell/Tools/AST/SemaInfoClasses.hs +++ b/Language/Haskell/Tools/AST/SemaInfoClasses.hs @@ -1,4 +1,9 @@ -{-# LANGUAGE FlexibleInstances, FlexibleContexts, ConstraintKinds #-} +{-# LANGUAGE FlexibleInstances + , FlexibleContexts + , ConstraintKinds + , TypeFamilies + , UndecidableInstances + #-} module Language.Haskell.Tools.AST.SemaInfoClasses where import GHC @@ -9,12 +14,14 @@ import Language.Haskell.Tools.AST.Ann as AST import Language.Haskell.Tools.AST.SemaInfoTypes as AST -import Language.Haskell.Tools.AST.Modules as AST -import Language.Haskell.Tools.AST.Base as AST -import Language.Haskell.Tools.AST.Exprs as AST +import Language.Haskell.Tools.AST.Representation.Modules as AST +import Language.Haskell.Tools.AST.Representation.Names as AST +import Language.Haskell.Tools.AST.Representation.Exprs as AST +-- * Information about names + -- | Domains that have semantic information for names -type HasNameInfo dom = (Domain dom, HasNameInfo' (SemanticInfo dom QualifiedName)) +type HasNameInfo dom = (Domain dom, HasNameInfo' (SemanticInfo dom UQualifiedName)) -- | Infos that may have a name that can be extracted class HasNameInfo' si where @@ -26,8 +33,13 @@ instance HasNameInfo' CNameInfo where semanticsName = fmap idName . (^? cnameInfo) -type HasIdInfo dom = (Domain dom, HasIdInfo' (SemanticInfo dom QualifiedName)) +instance HasNameInfo dom => HasNameInfo' (Ann UQualifiedName dom st) where + semanticsName = semanticsName . (^. annotation&semanticInfo) +-- * Information about typed names + +type HasIdInfo dom = (Domain dom, HasIdInfo' (SemanticInfo dom UQualifiedName)) + -- | Infos that may have a typed name that can be extracted class HasIdInfo' si where semanticsId :: si -> Id @@ -35,8 +47,13 @@ instance HasIdInfo' CNameInfo where semanticsId = (^. cnameInfo) -type HasFixityInfo dom = (Domain dom, HasFixityInfo' (SemanticInfo dom QualifiedName)) +instance HasIdInfo dom => HasIdInfo' (Ann UQualifiedName dom st) where + semanticsId = semanticsId . (^. annotation&semanticInfo) +-- * Fixity information + +type HasFixityInfo dom = (Domain dom, HasFixityInfo' (SemanticInfo dom UQualifiedName)) + -- | Infos that may have a fixity information class HasFixityInfo' si where semanticsFixity :: si -> Maybe GHC.Fixity @@ -44,8 +61,13 @@ instance HasFixityInfo' CNameInfo where semanticsFixity = (^. cnameFixity) -type HasScopeInfo dom = (Domain dom, HasScopeInfo' (SemanticInfo dom QualifiedName), HasScopeInfo' (SemanticInfo dom Expr)) +instance HasFixityInfo dom => HasFixityInfo' (Ann UQualifiedName dom st) where + semanticsFixity = semanticsFixity . (^. annotation&semanticInfo) +-- * Scope information + +type HasScopeInfo dom = (Domain dom, HasScopeInfo' (SemanticInfo dom UQualifiedName), HasScopeInfo' (SemanticInfo dom UExpr)) + -- | Infos that contain the names that are available in theirs scope class HasScopeInfo' si where semanticsScope :: si -> Scope @@ -59,8 +81,16 @@ instance HasScopeInfo' ScopeInfo where semanticsScope = (^. exprScopedLocals) -type HasDefiningInfo dom = (Domain dom, HasDefiningInfo' (SemanticInfo dom QualifiedName)) +instance HasScopeInfo dom => HasScopeInfo' (Ann UExpr dom st) where + semanticsScope = semanticsScope . (^. annotation&semanticInfo) +instance HasScopeInfo dom => HasScopeInfo' (Ann UQualifiedName dom st) where + semanticsScope = semanticsScope . (^. annotation&semanticInfo) + +-- * Information about names being defined + +type HasDefiningInfo dom = (Domain dom, HasDefiningInfo' (SemanticInfo dom UQualifiedName)) + -- | Infos that store if they were used to define a name class HasDefiningInfo' si where semanticsDefining :: si -> Bool @@ -71,8 +101,21 @@ instance HasDefiningInfo' CNameInfo where semanticsDefining = (^. cnameIsDefined) -type HasModuleInfo dom = (Domain dom, HasModuleInfo' (SemanticInfo dom AST.Module)) +instance HasDefiningInfo dom => HasDefiningInfo' (Ann UQualifiedName dom st) where + semanticsDefining = semanticsDefining . (^. annotation&semanticInfo) +-- * Information about source info in sema + +class HasSourceInfoInSema' si where + semanticsSourceInfo :: si -> Maybe SrcSpan + +instance HasSourceInfoInSema' (NameInfo n) where + semanticsSourceInfo = (^? nameLocation) + +-- * Information about modules + +type HasModuleInfo dom = (Domain dom, HasModuleInfo' (SemanticInfo dom AST.UModule)) + class HasModuleInfo' si where semanticsModule :: si -> GHC.Module isBootModule :: si -> Bool @@ -88,7 +131,14 @@ isBootModule = (^. defIsBootModule) semanticsImplicitImports = map idName . (^. implicitNames) -type HasImportInfo dom = (Domain dom, HasImportInfo' (SemanticInfo dom AST.ImportDecl)) +instance HasModuleInfo dom => HasModuleInfo' (Ann UModule dom st) where + semanticsModule = semanticsModule . (^. annotation&semanticInfo) + isBootModule = isBootModule . (^. annotation&semanticInfo) + semanticsImplicitImports = semanticsImplicitImports . (^. annotation&semanticInfo) + +-- * Information about imports + +type HasImportInfo dom = (Domain dom, HasImportInfo' (SemanticInfo dom AST.UImportDecl)) class HasImportInfo' si where semanticsImportedModule :: si -> GHC.Module @@ -105,10 +155,24 @@ semanticsAvailable = map idName . (^. availableNames) semanticsImported = map idName . (^. importedNames) -type HasImplicitFieldsInfo dom = (Domain dom, HasImplicitFieldsInfo' (SemanticInfo dom AST.FieldWildcard)) +instance HasImportInfo dom => HasImportInfo' (Ann UImportDecl dom st) where + semanticsImportedModule = semanticsImportedModule . (^. annotation&semanticInfo) + semanticsAvailable = semanticsAvailable . (^. annotation&semanticInfo) + semanticsImported = semanticsImported . (^. annotation&semanticInfo) + +-- * Information about implicitely bounded fields + +type HasImplicitFieldsInfo dom = (Domain dom, HasImplicitFieldsInfo' (SemanticInfo dom AST.UFieldWildcard)) class HasImplicitFieldsInfo' si where semanticsImplicitFlds :: si -> [(GHC.Name, GHC.Name)] instance HasImplicitFieldsInfo' ImplicitFieldInfo where semanticsImplicitFlds = (^. implicitFieldBindings) + +instance HasImplicitFieldsInfo dom => HasImplicitFieldsInfo' (Ann UFieldWildcard dom st) where + semanticsImplicitFlds = semanticsImplicitFlds . (^. annotation&semanticInfo) + +-- * AST elements with no information + +type HasNoSemanticInfo dom si = SemanticInfo dom si ~ NoSemanticInfo diff --git a/Language/Haskell/Tools/AST/SemaInfoTypes.hs b/Language/Haskell/Tools/AST/SemaInfoTypes.hs --- a/Language/Haskell/Tools/AST/SemaInfoTypes.hs +++ b/Language/Haskell/Tools/AST/SemaInfoTypes.hs @@ -4,7 +4,19 @@ , FlexibleContexts , FlexibleInstances #-} -module Language.Haskell.Tools.AST.SemaInfoTypes where +module Language.Haskell.Tools.AST.SemaInfoTypes + ( -- types + NoSemanticInfo, ScopeInfo, NameInfo, CNameInfo, ModuleInfo, ImportInfo, ImplicitFieldInfo + , Scope + -- references + , exprScopedLocals, nameScopedLocals, nameIsDefined, nameInfo, ambiguousName, nameLocation + , implicitName, cnameScopedLocals, cnameIsDefined, cnameInfo, cnameFixity + , defModuleName, defIsBootModule, implicitNames, importedModule, availableNames, importedNames + , implicitFieldBindings + -- creator functions + , mkNoSemanticInfo, mkScopeInfo, mkNameInfo, mkAmbiguousNameInfo, mkImplicitNameInfo, mkCNameInfo + , mkModuleInfo, mkImportInfo, mkImplicitFieldInfo + ) where import Name as GHC import BasicTypes as GHC @@ -14,6 +26,7 @@ import RdrName as GHC import Outputable as GHC +import Data.Maybe import Data.List import Data.Data @@ -26,11 +39,18 @@ data NoSemanticInfo = NoSemanticInfo deriving (Eq, Data) +mkNoSemanticInfo :: NoSemanticInfo +mkNoSemanticInfo = NoSemanticInfo + -- | Info for expressions that tells which definitions are in scope data ScopeInfo = ScopeInfo { _exprScopedLocals :: Scope } deriving (Eq, Data) +-- | Creates the information about the definitions in scope +mkScopeInfo :: Scope -> ScopeInfo +mkScopeInfo = ScopeInfo + -- | Info corresponding to a name data NameInfo n = NameInfo { _nameScopedLocals :: Scope , _nameIsDefined :: Bool @@ -39,16 +59,28 @@ | AmbiguousNameInfo { _nameScopedLocals :: Scope , _nameIsDefined :: Bool , _ambiguousName :: RdrName - , _ambiguousLocation :: SrcSpan + , _nameLocation :: SrcSpan } | ImplicitNameInfo { _nameScopedLocals :: Scope , _nameIsDefined :: Bool , _implicitName :: String - , _implicitLocation :: SrcSpan + , _nameLocation :: SrcSpan } deriving (Eq, Data) +-- | Creates semantic information for an unambiguous name +mkNameInfo :: Scope -> Bool -> n -> NameInfo n +mkNameInfo = NameInfo + +-- | Creates semantic information for a name that is ambiguous because the lack of type info +mkAmbiguousNameInfo :: Scope -> Bool -> RdrName -> SrcSpan -> NameInfo n +mkAmbiguousNameInfo = AmbiguousNameInfo + +-- | Creates semantic information for an implicit name +mkImplicitNameInfo :: Scope -> Bool -> String -> SrcSpan -> NameInfo n +mkImplicitNameInfo = ImplicitNameInfo + -- | Info corresponding to a name that is correctly identified data CNameInfo = CNameInfo { _cnameScopedLocals :: Scope , _cnameIsDefined :: Bool @@ -57,6 +89,10 @@ } deriving (Eq, Data) +-- | Create a typed name semantic information +mkCNameInfo :: Scope -> Bool -> Id -> Maybe GHC.Fixity -> CNameInfo +mkCNameInfo = CNameInfo + -- | Info for the module element data ModuleInfo n = ModuleInfo { _defModuleName :: GHC.Module , _defIsBootModule :: Bool -- ^ True if this module is created from a hs-boot file @@ -64,6 +100,10 @@ } deriving (Eq, Data) +-- | Creates semantic information for the module element +mkModuleInfo :: GHC.Module -> Bool -> [n] -> ModuleInfo n +mkModuleInfo = ModuleInfo + -- | Info corresponding to an import declaration data ImportInfo n = ImportInfo { _importedModule :: GHC.Module -- ^ The name and package of the imported module , _availableNames :: [n] -- ^ Names available from the imported module @@ -71,11 +111,19 @@ } deriving (Eq, Data) +-- | Creates semantic information for an import declaration +mkImportInfo :: GHC.Module -> [n] -> [n] -> ImportInfo n +mkImportInfo = ImportInfo + -- | Info corresponding to an record-wildcard data ImplicitFieldInfo = ImplicitFieldInfo { _implicitFieldBindings :: [(Name, Name)] -- ^ The implicitely bounded names } deriving (Eq, Data) +-- | Creates semantic information for a wildcard field binding +mkImplicitFieldInfo :: [(Name, Name)] -> ImplicitFieldInfo +mkImplicitFieldInfo = ImplicitFieldInfo + instance Show ScopeInfo where show (ScopeInfo locals) = "(ScopeInfo " ++ showSDocUnsafe (ppr locals) ++ ")" @@ -107,11 +155,32 @@ makeReferences ''ImportInfo makeReferences ''ImplicitFieldInfo --- | Semantic and source code related information for an AST node. -data NodeInfo sema src - = NodeInfo { _semanticInfo :: sema - , _sourceInfo :: src - } - deriving (Eq, Show, Data) - -makeReferences ''NodeInfo +instance Functor NameInfo where + fmap f = nameInfo .- f + +instance Functor ModuleInfo where + fmap f = implicitNames .- map f + +instance Functor ImportInfo where + fmap f (ImportInfo mod avail imps) = ImportInfo mod (map f avail) (map f imps) + +instance Foldable NameInfo where + foldMap f si = maybe mempty f (si ^? nameInfo) + +instance Foldable ModuleInfo where + foldMap f si = foldMap f (si ^. implicitNames) + +instance Foldable ImportInfo where + foldMap f si = foldMap f ((si ^. availableNames) ++ (si ^. importedNames)) + +instance Traversable NameInfo where + traverse f (NameInfo locals defined nameInfo) = NameInfo locals defined <$> f nameInfo + traverse f (AmbiguousNameInfo locals defined nameInfo span) = pure $ AmbiguousNameInfo locals defined nameInfo span + traverse f (ImplicitNameInfo locals defined nameInfo span) = pure $ ImplicitNameInfo locals defined nameInfo span + +instance Traversable ModuleInfo where + traverse f (ModuleInfo mod isboot imp) = ModuleInfo mod isboot <$> traverse f imp + +instance Traversable ImportInfo where + traverse f (ImportInfo mod avail imps) = ImportInfo mod <$> traverse f avail <*> traverse f imps + diff --git a/Language/Haskell/Tools/AST/Stmts.hs b/Language/Haskell/Tools/AST/Stmts.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Stmts.hs +++ /dev/null @@ -1,38 +0,0 @@ --- | Representation of Haskell statements (both do-notation and comprehensions) -module Language.Haskell.Tools.AST.Stmts where - -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Patterns -import {-# SOURCE #-} Language.Haskell.Tools.AST.Exprs (Expr, Cmd) -import {-# SOURCE #-} Language.Haskell.Tools.AST.Binds (LocalBind) - --- | Normal monadic statements -data Stmt' expr dom stage - = BindStmt { _stmtPattern :: Ann Pattern dom stage - , _stmtExpr :: Ann expr dom stage - } -- ^ Binding statement (@ x <- action @) - | ExprStmt { _stmtExpr :: Ann expr dom stage - } -- ^ Non-binding statement (@ action @) - | LetStmt { _stmtBinds :: AnnList LocalBind dom stage - } -- ^ Let statement (@ let x = 3; y = 4 @) - | RecStmt { _cmdStmtBinds :: AnnList (Stmt' expr) dom stage - } -- ^ A recursive binding statement with (@ rec b <- f a c; c <- f b a @) -type Stmt = Stmt' Expr - --- | Body of a list comprehension: (@ | x <- [1..10] @) -data ListCompBody dom stage - = ListCompBody { _compStmts :: AnnList CompStmt dom stage - } - --- | List comprehension statement -data CompStmt dom stage - = CompStmt { _compStmt :: Ann Stmt dom stage - } -- ^ Normal monadic statement of a list comprehension - | ThenStmt { _thenExpr :: Ann Expr dom stage - , _byExpr :: AnnMaybe Expr dom stage - } -- ^ Then statements by @TransformListComp@ (@ then sortWith by (x + y) @) - | GroupStmt { _byExpr :: AnnMaybe Expr dom stage - , _usingExpr :: AnnMaybe Expr dom stage - } -- ^ Grouping statements by @TransformListComp@ (@ then group by (x + y) using groupWith @) - -- Note: either byExpr or usingExpr must have a value diff --git a/Language/Haskell/Tools/AST/TH.hs b/Language/Haskell/Tools/AST/TH.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/TH.hs +++ /dev/null @@ -1,41 +0,0 @@ --- | Representation of Template Haskell AST elements -module Language.Haskell.Tools.AST.TH where - -import Language.Haskell.Tools.AST.Decls -import Language.Haskell.Tools.AST.Binds -import Language.Haskell.Tools.AST.Exprs -import Language.Haskell.Tools.AST.Patterns -import Language.Haskell.Tools.AST.Types -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Ann - --- | A template haskell splice -data Splice dom stage - = IdSplice { _spliceId :: Ann Name dom stage - } -- ^ A simple name splice: @$generateX@ - | ParenSplice { _spliceExpr :: Ann Expr dom stage - } -- ^ A splice with parentheses: @$(generate input)@ - --- | Template haskell quasi-quotation: @[quoter|str]@ -data QuasiQuote dom stage - = QuasiQuote { _qqExprName :: Ann Name dom stage - , _qqExprBody :: Ann QQString dom stage - } - --- | Template Haskell Quasi-quotation content -data QQString dom stage - = QQString { _qqString :: String - } - - --- | Template Haskell bracket expressions -data Bracket dom stage - = ExprBracket { _bracketExpr :: Ann Expr dom stage - } -- ^ Expression bracket (@ [| x + y |] @) - | PatternBracket { _bracketPattern :: Ann Pattern dom stage - } -- ^ Pattern bracket (@ [| Point x y |] @) - | TypeBracket { _bracketType :: Ann Type dom stage - } -- ^ Pattern bracket (@ [| (Int,Int) |] @) - | DeclsBracket { _bracketDecl :: AnnList Decl dom stage - } -- ^ Declaration bracket (@ [| _f :: Int -> Int; f x = x*x |] @) - diff --git a/Language/Haskell/Tools/AST/TH.hs-boot b/Language/Haskell/Tools/AST/TH.hs-boot deleted file mode 100644 --- a/Language/Haskell/Tools/AST/TH.hs-boot +++ /dev/null @@ -1,11 +0,0 @@ -{-# LANGUAGE RoleAnnotations #-} -module Language.Haskell.Tools.AST.TH where - -type role Splice nominal nominal -data Splice dom stage - -type role QuasiQuote nominal nominal -data QuasiQuote dom stage - -type role Bracket nominal nominal -data Bracket dom stage diff --git a/Language/Haskell/Tools/AST/Types.hs b/Language/Haskell/Tools/AST/Types.hs deleted file mode 100644 --- a/Language/Haskell/Tools/AST/Types.hs +++ /dev/null @@ -1,87 +0,0 @@ --- | Representation of Haskell types -module Language.Haskell.Tools.AST.Types where - -import Language.Haskell.Tools.AST.Ann -import Language.Haskell.Tools.AST.Literals -import Language.Haskell.Tools.AST.Base -import Language.Haskell.Tools.AST.Kinds -import {-# SOURCE #-} Language.Haskell.Tools.AST.TH - --- | Type variable declaration -data TyVar dom stage - = TyVarDecl { _tyVarName :: Ann Name dom stage - , _tyVarKind :: AnnMaybe KindConstraint dom stage - } - --- | Haskell types -data Type dom stage - = TyForall { _typeBounded :: AnnList TyVar dom stage - , _typeType :: Ann Type dom stage - } -- ^ Forall types (@ forall x y . type @) - | TyCtx { _typeCtx :: Ann Context dom stage - , _typeType :: Ann Type dom stage - } -- ^ Type with a context (@ forall x y . type @) - | TyFun { _typeParam :: Ann Type dom stage - , _typeResult :: Ann Type dom stage - } -- ^ Function types (@ a -> b @) - | TyTuple { _typeElements :: AnnList Type dom stage - } -- ^ Tuple types (@ (a,b) @) - | TyUnbTuple { _typeElements :: AnnList Type dom stage - } -- ^ Unboxed tuple types (@ (#a,b#) @) - | TyList { _typeElement :: Ann Type dom stage - } -- ^ List type with special syntax (@ [a] @) - | TyParArray { _typeElement :: Ann Type dom stage - } -- ^ Parallel array type (@ [:a:] @) - | TyApp { _typeCon :: Ann Type dom stage - , _typeArg :: Ann Type dom stage - } -- ^ Type application (@ F a @) - | TyVar { _typeName :: Ann Name dom stage - } -- ^ type variable or constructor (@ a @) - | TyParen { _typeInner :: Ann Type dom stage - } -- ^ type surrounded by parentheses (@ (T a) @) - | TyInfix { _typeLeft :: Ann Type dom stage - , _typeOperator :: Ann Operator dom stage - , _typeRight :: Ann Type dom stage - } -- ^ Infix type constructor (@ (a <: b) @) - | TyKinded { _typeInner :: Ann Type dom stage - , _typeKind :: Ann Kind dom stage - } -- ^ Type with explicit kind signature (@ _a :: * @) - | TyPromoted { _tpPromoted :: Ann (Promoted Type) dom stage - } -- A promoted data type with @-XDataKinds@ (@ 3 @, @ Left @, @ 'Left @). - | TySplice { _tsSplice :: Splice dom stage - } -- ^ a Template Haskell splice type (@ $(genType) @). - | TyQuasiQuote { _typeQQ :: QuasiQuote dom stage - } -- ^ a Template Haskell quasi-quote type (@ [quoter| ... ] @). - | TyBang { _typeInner :: Ann Type dom stage - } -- ^ Strict type marked with @!@. - | TyLazy { _typeInner :: Ann Type dom stage - } -- ^ Lazy type marked with @~@. (Should only be used if @Strict@ or @StrictData@ language extension is used) - | TyUnpack { _typeInner :: Ann Type dom stage - } -- ^ Strict type marked with UNPACK pragma. (Usually contains the bang mark.) - | TyNoUnpack { _typeInner :: Ann Type dom stage - } -- ^ Strict type marked with NOUNPACK pragma. (Usually contains the bang mark.) - | TyWildcard -- ^ A wildcard type (@ _ @) with @-XPartialTypeSignatures@ - | TyNamedWildc { _typeWildcardName :: Ann Name dom stage - } -- ^ A named wildcard type (@ _t @) with @-XPartialTypeSignatures@ - --- One or more assertions -data Context dom stage - = ContextOne { _contextAssertion :: Ann Assertion dom stage - } -- ^ One assertion (@ C a => ... @) - | ContextMulti { _contextAssertions :: AnnList Assertion dom stage - } -- ^ A set of assertions (@ (C1 a, C2 b) => ... @, but can be one: @ (C a) => ... @) - --- | A single assertion in the context -data Assertion dom stage - = ClassAssert { _assertClsName :: Ann Name dom stage - , _assertTypes :: AnnList Type dom stage - } -- ^ Class assertion (@Cls x@) - | InfixAssert { _assertLhs :: Ann Type dom stage - , _assertOp :: Ann Operator dom stage - , _assertRhs :: Ann Type dom stage - } -- ^ Infix class assertion, also contains type equations (@ a ~ X y @) - | ImplicitAssert { _assertImplVar :: Ann Name dom stage - , _assertImplType :: Ann Type dom stage - } -- ^ Assertion for implicit parameter binding (@ ?cmp :: a -> a -> Bool @) - - diff --git a/haskell-tools-ast.cabal b/haskell-tools-ast.cabal --- a/haskell-tools-ast.cabal +++ b/haskell-tools-ast.cabal @@ -1,5 +1,5 @@ name: haskell-tools-ast -version: 0.2.0.0 +version: 0.3.0.0 synopsis: Haskell AST for efficient tooling description: A representation of a Haskell Syntax tree that contain source-related and semantic annotations. These annotations help developer tools to work with the defined program. The source information enables refactoring and program transformation tools to change the source code without losing the original format (layout, comments) of the source. Semantic information helps analyzing the program. The representation is different from the GHC's syntax tree. It contains information from all representations in GHC (different version of syntax trees, lexical and module-level information). The module is split up to put the representation of different language elements into different modules. Additionally, it contains the representation of semantic and source annotations, helper functions and generated instances for the representation of language elements. Because langauge elements may refer each other (there can be a pattern inside an expression in case of a pattern match and an expression inside a pattern if view patterns are enabled), we use hs-boot files to break up dependency cycles. @@ -13,22 +13,29 @@ cabal-version: >=1.10 library - exposed-modules: Language.Haskell.Tools.AST - , Language.Haskell.Tools.AST.Modules - , Language.Haskell.Tools.AST.TH - , Language.Haskell.Tools.AST.Decls - , Language.Haskell.Tools.AST.Binds - , Language.Haskell.Tools.AST.Exprs - , Language.Haskell.Tools.AST.Stmts - , Language.Haskell.Tools.AST.Patterns - , Language.Haskell.Tools.AST.Types - , Language.Haskell.Tools.AST.Kinds - , Language.Haskell.Tools.AST.Literals - , Language.Haskell.Tools.AST.Base + exposed-modules: Language.Haskell.Tools.AST + , Language.Haskell.Tools.AST.References + , Language.Haskell.Tools.AST.Helpers , Language.Haskell.Tools.AST.Ann , Language.Haskell.Tools.AST.SemaInfoTypes - , Language.Haskell.Tools.AST.SemaInfoClasses - + , Language.Haskell.Tools.AST.SemaInfoClasses + + other-modules: Language.Haskell.Tools.AST.Representation.Modules + , Language.Haskell.Tools.AST.Representation.TH + , Language.Haskell.Tools.AST.Representation.Decls + , Language.Haskell.Tools.AST.Representation.Binds + , Language.Haskell.Tools.AST.Representation.Exprs + , Language.Haskell.Tools.AST.Representation.Stmts + , Language.Haskell.Tools.AST.Representation.Patterns + , Language.Haskell.Tools.AST.Representation.Types + , Language.Haskell.Tools.AST.Representation.Kinds + , Language.Haskell.Tools.AST.Representation.Literals + , Language.Haskell.Tools.AST.Representation.Names + + , Language.Haskell.Tools.AST.MakeASTReferences + , Language.Haskell.Tools.AST.Utils.OrdSrcSpan + , Language.Haskell.Tools.AST.Utils.GHCInstances + , Language.Haskell.Tools.AST.Instances , Language.Haskell.Tools.AST.Instances.Eq , Language.Haskell.Tools.AST.Instances.Show @@ -38,15 +45,11 @@ , Language.Haskell.Tools.AST.Instances.SourceInfoTraversal , Language.Haskell.Tools.AST.TH.SemanticTraversal , Language.Haskell.Tools.AST.TH.SourceInfoTraversal - , Language.Haskell.Tools.AST.References - , Language.Haskell.Tools.AST.Helpers - , Language.Haskell.Tools.AST.Utils.OrdSrcSpan - , Language.Haskell.Tools.AST.Utils.GHCInstances - build-depends: base >=4.9 && <5.0 - , ghc >=8.0 && <8.1 - , references >=0.3.2 && <1.0 - , uniplate >=1.6 && <2.0 - , mtl >=2.2 && <3.0 - , template-haskell >=2.11 && <3.0 + build-depends: base >= 4.9 && < 4.10 + , ghc >= 8.0 && < 8.1 + , references >= 0.3 && < 0.4 + , uniplate >= 1.6 && < 1.7 + , mtl >= 2.2 && < 2.3 + , template-haskell >= 2.11 && < 2.12 default-language: Haskell2010