haskell-tools-ast 0.4.1.3 → 0.5.0.0

raw patch · 20 files changed

+100/−85 lines, 20 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Language/Haskell/Tools/AST/Helpers.hs +10/−8
• Language/Haskell/Tools/AST/Instances/Data.hs +1/−0
• Language/Haskell/Tools/AST/Instances/Eq.hs +1/−0
• Language/Haskell/Tools/AST/Instances/Generic.hs +1/−0
• Language/Haskell/Tools/AST/Instances/SemanticTraversal.hs +1/−0
• Language/Haskell/Tools/AST/Instances/Show.hs +1/−0
• Language/Haskell/Tools/AST/Instances/SourceInfoTraversal.hs +1/−0
• Language/Haskell/Tools/AST/Representation/Binds.hs +36/−6
• Language/Haskell/Tools/AST/Representation/Decls.hs +12/−35
• Language/Haskell/Tools/AST/Representation/Exprs.hs +6/−6
• Language/Haskell/Tools/AST/Representation/Kinds.hs +2/−2
• Language/Haskell/Tools/AST/Representation/Modules.hs +4/−4
• Language/Haskell/Tools/AST/Representation/Names.hs +1/−1
• Language/Haskell/Tools/AST/Representation/Patterns.hs +5/−5
• Language/Haskell/Tools/AST/Representation/Stmts.hs +2/−2
• Language/Haskell/Tools/AST/Representation/TH.hs +6/−6
• Language/Haskell/Tools/AST/Representation/Types.hs +4/−4
• Language/Haskell/Tools/AST/SemaInfoClasses.hs +4/−4
• Language/Haskell/Tools/AST/Utils/OrdSrcSpan.hs +1/−1
• haskell-tools-ast.cabal +1/−1

@@ -11,7 +11,7 @@ -- | Helper functions for using the AST.
 module Language.Haskell.Tools.AST.Helpers where
 
-import qualified Name as GHC (Name(..))
+import qualified Name as GHC (Name)
 import SrcLoc
 
 import Control.Reference
@@ -22,13 +22,13 @@ 
 import Language.Haskell.Tools.AST.Ann
 import Language.Haskell.Tools.AST.References
-import Language.Haskell.Tools.AST.Representation.Binds (ULocalBind(..), UValueBind(..))
-import Language.Haskell.Tools.AST.Representation.Decls (UDeclHead(..), UDecl(..))
-import Language.Haskell.Tools.AST.Representation.Modules (UImportDecl(..))
-import Language.Haskell.Tools.AST.Representation.Names (UQualifiedName(..))
-import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import Language.Haskell.Tools.AST.Representation.Binds (ULocalBind, UValueBind)
+import Language.Haskell.Tools.AST.Representation.Decls (UDeclHead, UDecl)
+import Language.Haskell.Tools.AST.Representation.Modules (UImportDecl)
+import Language.Haskell.Tools.AST.Representation.Names (UQualifiedName)
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern)
 import Language.Haskell.Tools.AST.Representation.Types (UType(..))
-import Language.Haskell.Tools.AST.SemaInfoTypes (Scope(..))
+import Language.Haskell.Tools.AST.SemaInfoTypes (Scope)
  
 -- | Does the import declaration import only the explicitly listed elements?
 importIsExact :: Ann UImportDecl dom stage -> Bool
@@ -117,7 +117,9 @@                   &+& (declPatSyn & patLhs & (patName & simpleName &+& patSynOp & operatorName))
 
 instance NamedElement ULocalBind where
-  elementName = localVal&bindingName &+& localSig&tsName&annList&simpleName
+  elementName = localVal&bindingName 
+                  &+& localSig&tsName&annList&simpleName 
+                  &+& localFixity&fixityOperators&annList&operatorName
 
 inScope :: GHC.Name -> Scope -> Bool
 inScope n sc = any (n `elem`) sc

@@ -107,6 +107,7 @@ 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)
+deriving instance (Domain dom, SourceInfo stage) => Data (UInlinePragma dom stage)
 
 -- ULiteral
 deriving instance (Domain dom, SourceInfo stage) => Data (ULiteral dom stage)

@@ -110,6 +110,7 @@ deriving instance Eq (UCmd dom stage)
 deriving instance Eq (ULanguageExtension dom stage)
 deriving instance Eq (UMatchLhs dom stage)
+deriving instance Eq (UInlinePragma dom stage)
 
 -- ULiteral
 deriving instance Eq (ULiteral dom stage)

@@ -107,6 +107,7 @@ deriving instance Domain dom => Generic (UCmd dom stage)
 deriving instance Domain dom => Generic (ULanguageExtension dom stage)
 deriving instance Domain dom => Generic (UMatchLhs dom stage)
+deriving instance Domain dom => Generic (UInlinePragma dom stage)
 
 
 -- Literal

@@ -105,6 +105,7 @@ deriveSemanticTraversal ''UAlt'
 deriveSemanticTraversal ''UCaseRhs'
 deriveSemanticTraversal ''UGuardedCaseRhs'
+deriveSemanticTraversal ''UInlinePragma
 
 -- ULiteral
 deriveSemanticTraversal ''ULiteral

@@ -110,6 +110,7 @@ deriving instance Show (UCmd dom stage)
 deriving instance Show (ULanguageExtension dom stage)
 deriving instance Show (UMatchLhs dom stage)
+deriving instance Show (UInlinePragma dom stage)
 
 
 -- ULiteral

@@ -105,6 +105,7 @@ deriveSourceInfoTraversal ''UAlt'
 deriveSourceInfoTraversal ''UCaseRhs'
 deriveSourceInfoTraversal ''UGuardedCaseRhs'
+deriveSourceInfoTraversal ''UInlinePragma
 
 -- ULiteral
 deriveSourceInfoTraversal ''ULiteral

@@ -1,11 +1,11 @@ -- | 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 (Ann(..), AnnListG(..), AnnMaybeG(..))
-import Language.Haskell.Tools.AST.Representation.Exprs (UExpr(..))
-import Language.Haskell.Tools.AST.Representation.Names (UName(..), UOperator(..))
-import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
-import Language.Haskell.Tools.AST.Representation.Types (UType(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG, AnnMaybeG)
+import Language.Haskell.Tools.AST.Representation.Exprs (UExpr)
+import Language.Haskell.Tools.AST.Representation.Names (UName, UOperator)
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern)
+import Language.Haskell.Tools.AST.Representation.Types (UType)
 
 -- | Value binding for top-level and local bindings
 data UValueBind dom stage
@@ -49,6 +49,8 @@                     } -- ^ A local type signature
   | ULocalFixity    { _localFixity :: Ann UFixitySignature dom stage
                     } -- ^ A local fixity declaration
+  | ULocalInline    { _localInline :: Ann UInlinePragma dom stage
+                    } -- ^ A local inline pragma
                    
 -- | A type signature (@ f :: Int -> Int @)
 data UTypeSignature dom stage
@@ -61,7 +63,7 @@ -- | A fixity signature (@ infixl 5 +, - @).
 data UFixitySignature dom stage
   = UFixitySignature { _fixityAssoc :: Ann Assoc dom stage
-                     , _fixityPrecedence :: Ann Precedence dom stage
+                     , _fixityPrecedence :: AnnMaybeG Precedence dom stage
                      , _fixityOperators :: AnnListG UOperator dom stage
                      }
 
@@ -97,3 +99,31 @@                 } -- ^ A let statement in a pattern guard (@ let x = 3 @)
   | UGuardCheck { _guardCheck :: Ann UExpr dom stage
                 } -- ^ An expression to check for a pattern guard
+
+-- | Pragmas that control how the definitions will be inlined
+data UInlinePragma dom stage
+  = UInlinePragma     { _inlineConlike :: AnnMaybeG UConlikeAnnot dom stage
+                      , _inlinePhase :: AnnMaybeG UPhaseControl dom stage
+                      , _inlineDef :: Ann UName dom stage
+                      } -- ^ A pragma that marks a function for inlining to the compiler (@ {-# INLINE thenUs #-} @)
+  | UNoInlinePragma   { _noInlineDef :: Ann UName dom stage
+                      } -- ^ A pragma that forbids a function from being inlined by the compiler (@ {-# NOINLINE f #-} @)
+  | UInlinablePragma  { _inlinePhase :: 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 #-} @)
+
+-- | A @CONLIKE@ modifier for an @INLINE@ pragma.
+data UConlikeAnnot dom stage = UConlikeAnnot
+
+-- | 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

@@ -2,14 +2,14 @@ -- The definition of value bindings are in the Binds module.
 module Language.Haskell.Tools.AST.Representation.Decls where
 
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG, AnnMaybeG)
 import Language.Haskell.Tools.AST.Representation.Binds
-import Language.Haskell.Tools.AST.Representation.Exprs (UExpr(..))
-import Language.Haskell.Tools.AST.Representation.Kinds (UKindConstraint(..))
+import Language.Haskell.Tools.AST.Representation.Exprs (UExpr)
+import Language.Haskell.Tools.AST.Representation.Kinds (UKindConstraint)
 import Language.Haskell.Tools.AST.Representation.Names
-import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (USplice(..))
-import Language.Haskell.Tools.AST.Representation.Types (UContext(..), UType(..), UTyVar(..))
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern)
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (USplice)
+import Language.Haskell.Tools.AST.Representation.Types (UContext, UType, UTyVar)
 
 -- * Declarations
 
@@ -129,6 +129,8 @@                 } -- ^ Default signature (by using @DefaultSignatures@): @ default _enum :: (Generic a, GEnum (Rep a)) => [a] @
   | UClsMinimal { _pragmaFormula :: Ann UMinimalFormula dom stage
                 } -- ^ Minimal pragma: @ {-# MINIMAL (==) | (/=) #-} @
+  | UClsInline  { _clsInline :: Ann UInlinePragma dom stage
+                } -- ^ Inline-like pragma in class definition
   -- not supported yet (GHC 8.0.1)
 -- | UClsPatSig  { _cePatSig :: Ann UPatternTypeSignature dom stage
   --               } -- ^ Pattern signature in a class declaration (by using @PatternSynonyms@)
@@ -181,6 +183,8 @@                           } -- ^ An associated data type implemented using GADT style
   | USpecializeInstance   { _specializeInstanceType :: Ann UType dom stage
                           } -- ^ Specialize instance pragma (no phase selection is allowed)
+  | UInlineInstance       { _instanceInline :: Ann UInlinePragma dom stage
+                          } -- ^ Inline-like pragma in a class instance
   -- not supported yet
 -- | UInstBodyPatSyn       { _instBodyPatSyn :: Ann UPatternSynonym dom stage
   --                         } -- ^ A pattern synonym in a class instance
@@ -348,21 +352,6 @@   | 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
@@ -378,17 +367,8 @@   | 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 #-} @)
+  -- TODO: extract pragmas that appear both in top-level and in instances (inline, inlinable, noinline)
+  | UInlinePragmaDecl { _pragmaInline :: Ann UInlinePragma dom stage }
   | ULinePragma       { _pragmaLineNum :: Ann LineNumber dom stage
                       , _pragmaFileName :: AnnMaybeG UStringNode dom stage
                       } -- ^ A pragma for maintaining line numbers in generated sources (@ {-# LINE 123 "somefile" #-} @)
@@ -424,9 +404,6 @@                   } -- ^ 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

@@ -1,14 +1,14 @@ -- | Representation of Haskell expressions
 module Language.Haskell.Tools.AST.Representation.Exprs where
 
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG, AnnMaybeG)
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Binds (ULocalBind, ULocalBinds, URhsGuard)
-import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
-import Language.Haskell.Tools.AST.Representation.Names (UStringNode(..), UName(..), UOperator(..))
-import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral)
+import Language.Haskell.Tools.AST.Representation.Names (UStringNode, UName, UOperator)
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern)
 import Language.Haskell.Tools.AST.Representation.Stmts
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UBracket(..), UQuasiQuote(..), USplice(..))
-import Language.Haskell.Tools.AST.Representation.Types (UType(..))
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UBracket, UQuasiQuote, USplice)
+import Language.Haskell.Tools.AST.Representation.Types (UType)
 
 -- | Haskell expressions
 data UExpr dom stage

@@ -1,8 +1,8 @@ -- | Representation of Haskell Kinds
 module Language.Haskell.Tools.AST.Representation.Kinds where
 
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
-import Language.Haskell.Tools.AST.Representation.Names (UName(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG)
+import Language.Haskell.Tools.AST.Representation.Names (UName)
 
 -- | Kind constraint (@ :: * -> * @)
 data UKindConstraint dom stage

@@ -1,9 +1,9 @@ -- | 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 (Ann(..), AnnListG(..), AnnMaybeG(..))
-import Language.Haskell.Tools.AST.Representation.Decls (UDecl(..))
-import Language.Haskell.Tools.AST.Representation.Names (UStringNode(..), UName(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG, AnnMaybeG)
+import Language.Haskell.Tools.AST.Representation.Decls (UDecl)
+import Language.Haskell.Tools.AST.Representation.Names (UStringNode, UName)
 
 -- | The representation of a haskell module, that is a separate compilation unit.
 -- It may or may not have a header.
@@ -17,8 +17,8 @@ -- | 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
+                , _mhExports :: AnnMaybeG UExportSpecs dom stage
                 }
 
 -- | A list of export specifications surrounded by parentheses

@@ -7,7 +7,7 @@ -- | Simple AST elements of Haskell
 module Language.Haskell.Tools.AST.Representation.Names where
   
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG(..))
 
 data UOperator dom stage
   = UBacktickOp { _operatorName :: Ann UQualifiedName dom stage 

@@ -1,12 +1,12 @@ -- | Representation of Haskell patterns
 module Language.Haskell.Tools.AST.Representation.Patterns where
           
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG)
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UFieldWildcard)  
-import Language.Haskell.Tools.AST.Representation.Literals (ULiteral(..))
-import Language.Haskell.Tools.AST.Representation.Names (UName(..), UOperator(..))
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UQuasiQuote(..), USplice(..))
-import Language.Haskell.Tools.AST.Representation.Types (UType(..))
+import Language.Haskell.Tools.AST.Representation.Literals (ULiteral)
+import Language.Haskell.Tools.AST.Representation.Names (UName, UOperator)
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UQuasiQuote, USplice)
+import Language.Haskell.Tools.AST.Representation.Types (UType)
 
         
 -- | Representation of patterns for pattern bindings

@@ -1,10 +1,10 @@ -- | Representation of Haskell statements (both do-notation and comprehensions)
 module Language.Haskell.Tools.AST.Representation.Stmts where
 
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG, AnnMaybeG)
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Binds (ULocalBind)
 import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.Exprs (UExpr, UCmd)
-import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern)
 
 -- | Normal monadic statements
 data UStmt' expr dom stage

@@ -1,12 +1,12 @@ -- | Representation of Template Haskell AST elements
 module Language.Haskell.Tools.AST.Representation.TH where
               
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..))
-import Language.Haskell.Tools.AST.Representation.Decls (UDecl(..))
-import Language.Haskell.Tools.AST.Representation.Exprs (UExpr(..))
-import Language.Haskell.Tools.AST.Representation.Names (UName(..))
-import Language.Haskell.Tools.AST.Representation.Patterns (UPattern(..))
-import Language.Haskell.Tools.AST.Representation.Types (UType(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG)
+import Language.Haskell.Tools.AST.Representation.Decls (UDecl)
+import Language.Haskell.Tools.AST.Representation.Exprs (UExpr)
+import Language.Haskell.Tools.AST.Representation.Names (UName)
+import Language.Haskell.Tools.AST.Representation.Patterns (UPattern)
+import Language.Haskell.Tools.AST.Representation.Types (UType)
               
 -- | A template haskell splice          
 data USplice dom stage

@@ -1,10 +1,10 @@ -- | Representation of Haskell types
 module Language.Haskell.Tools.AST.Representation.Types where
 
-import Language.Haskell.Tools.AST.Ann (Ann(..), AnnListG(..), AnnMaybeG(..))
-import Language.Haskell.Tools.AST.Representation.Kinds (UPromoted(..), UKind(..), UKindConstraint(..))
-import Language.Haskell.Tools.AST.Representation.Names (UName(..), UOperator(..))
-import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UQuasiQuote(..), USplice(..))
+import Language.Haskell.Tools.AST.Ann (Ann, AnnListG, AnnMaybeG)
+import Language.Haskell.Tools.AST.Representation.Kinds (UPromoted, UKind, UKindConstraint)
+import Language.Haskell.Tools.AST.Representation.Names (UName, UOperator)
+import {-# SOURCE #-} Language.Haskell.Tools.AST.Representation.TH (UQuasiQuote, USplice)
 
 -- | Type variable declaration
 data UTyVar dom stage

@@ -7,14 +7,14 @@ module Language.Haskell.Tools.AST.SemaInfoClasses where
 
 import GHC
-import Id as GHC (Id(..), idName)
+import Id as GHC (Id, idName)
 
 import Control.Reference ((^?), (^.), (&))
 
 import Language.Haskell.Tools.AST.Ann as AST
-import Language.Haskell.Tools.AST.Representation.Exprs as AST (UFieldWildcard(..), UExpr(..))
-import Language.Haskell.Tools.AST.Representation.Modules as AST (UImportDecl(..), UModule(..))
-import Language.Haskell.Tools.AST.Representation.Names as AST (UQualifiedName(..))
+import Language.Haskell.Tools.AST.Representation.Exprs as AST (UFieldWildcard, UExpr)
+import Language.Haskell.Tools.AST.Representation.Modules as AST (UImportDecl, UModule)
+import Language.Haskell.Tools.AST.Representation.Names as AST (UQualifiedName)
 import Language.Haskell.Tools.AST.SemaInfoTypes as AST
 
 -- * Information about names

@@ -1,7 +1,7 @@ -- | A wrapper for SrcSpans that is ordered.
 module Language.Haskell.Tools.AST.Utils.OrdSrcSpan where
 
-import FastString (FastString(..))
+import FastString (FastString)
 import SrcLoc
 
 -- | Wraps the SrcSpan into an ordered source span

@@ -1,5 +1,5 @@ name:                haskell-tools-ast
-version:             0.4.1.3
+version:             0.5.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.